diff --git a/pkg/front_end/tool/generate_ast_equivalence.dart b/pkg/front_end/tool/generate_ast_equivalence.dart
index c401b0f..56b049c 100644
--- a/pkg/front_end/tool/generate_ast_equivalence.dart
+++ b/pkg/front_end/tool/generate_ast_equivalence.dart
@@ -150,8 +150,6 @@
         registerAstClassEquivalence(utilityFieldType.astClass);
         sb.writeln('''($thisName, $otherName, _) {
     if (identical($thisName, $otherName)) return true;
-    if ($thisName is! ${utilityFieldType.astClass.name}) return false;
-    if ($otherName is! ${utilityFieldType.astClass.name}) return false;
     return ${classCheckName(utilityFieldType.astClass)}(
         visitor,
         $thisName,
@@ -209,8 +207,6 @@
         registerAstClassEquivalence(utilityFieldType.astClass);
         sb.writeln('''($thisName, $otherName, _) {
     if (identical($thisName, $otherName)) return true;
-    if ($thisName is! ${utilityFieldType.astClass.name}) return false;
-    if ($otherName is! ${utilityFieldType.astClass.name}) return false;
     return ${classCheckName(utilityFieldType.astClass)}(
         visitor,
         $thisName,
@@ -625,7 +621,7 @@
   bool $checkLists<E>(
             List<E>? a,
             List<E>? b,
-            bool Function(E?, E?, String) equivalentValues,
+            bool Function(E, E, String) equivalentValues,
             [String propertyName = '']) {
           if (identical(a, b)) return true;
           if (a == null || b == null) return false;
@@ -651,8 +647,8 @@
   bool $checkSets<E>(
             Set<E>? a,
             Set<E>? b,
-            bool Function(E?, E?) matchingValues,
-            bool Function(E?, E?, String) equivalentValues,
+            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;
@@ -702,9 +698,9 @@
   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,
+            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;
@@ -733,7 +729,7 @@
             }
             if (hasFoundKey) {
               bKeys.remove(foundKey);
-              if (!equivalentValues(a[aKey], b[foundKey],
+              if (!equivalentValues(a[aKey]!, b[foundKey]!,
                   '\${propertyName}[\${aKey}]')) {
                 return false;
               }
diff --git a/pkg/kernel/bin/check_equivalence.dart b/pkg/kernel/bin/check_equivalence.dart
new file mode 100644
index 0000000..a9cbf2e
--- /dev/null
+++ b/pkg/kernel/bin/check_equivalence.dart
@@ -0,0 +1,6 @@
+#!/usr/bin/env dart
+// Copyright (c) 2025, 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.
+
+export 'package:kernel/src/tool/check_equivalence.dart';
diff --git a/pkg/kernel/lib/src/equivalence.dart b/pkg/kernel/lib/src/equivalence.dart
index fc463b9..0c3bb47 100644
--- a/pkg/kernel/lib/src/equivalence.dart
+++ b/pkg/kernel/lib/src/equivalence.dart
@@ -1253,7 +1253,7 @@
   /// 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,
+      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;
@@ -1276,8 +1276,8 @@
   ///
   /// 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,
+  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;
@@ -1325,9 +1325,9 @@
   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,
+      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;
@@ -1355,7 +1355,7 @@
       if (hasFoundKey) {
         bKeys.remove(foundKey);
         if (!equivalentValues(
-            a[aKey], b[foundKey], '${propertyName}[${aKey}]')) {
+            a[aKey]!, b[foundKey]!, '${propertyName}[${aKey}]')) {
           return false;
         }
       } else {
@@ -5716,8 +5716,6 @@
       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');
   }
@@ -5902,8 +5900,6 @@
     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');
   }
@@ -5914,8 +5910,6 @@
         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');
   }
@@ -6089,8 +6083,6 @@
     return visitor.checkLists(node.memberDescriptors, other.memberDescriptors,
         (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);
     }, 'memberDescriptors');
   }
@@ -6192,8 +6184,6 @@
     return visitor.checkLists(node.memberDescriptors, other.memberDescriptors,
         (a, b, _) {
       if (identical(a, b)) return true;
-      if (a is! ExtensionTypeMemberDescriptor) return false;
-      if (b is! ExtensionTypeMemberDescriptor) return false;
       return checkExtensionTypeMemberDescriptor(visitor, a, b);
     }, 'memberDescriptors');
   }
diff --git a/pkg/kernel/lib/src/tool/check_equivalence.dart b/pkg/kernel/lib/src/tool/check_equivalence.dart
new file mode 100644
index 0000000..42dea47
--- /dev/null
+++ b/pkg/kernel/lib/src/tool/check_equivalence.dart
@@ -0,0 +1,408 @@
+// Copyright (c) 2025, 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.
+
+import 'dart:io';
+
+import 'package:_fe_analyzer_shared/src/util/options.dart';
+import 'package:kernel/ast.dart';
+import 'package:kernel/src/equivalence.dart';
+import 'package:kernel/src/tool/command_line_util.dart';
+
+void main(List<String> args) {
+  ParsedOptions parsedOptions = ParsedOptions.parse(args, optionSpecification);
+
+  CommandLineHelper.requireVariableArgumentCount([2], parsedOptions.arguments,
+      () {
+    print('''
+Usage:
+
+    dart check_equivalence.dart [options] <dill1> <dill2>
+''');
+  });
+  if (parsedOptions.arguments.length != 2) {
+    exit(1);
+  }
+
+  bool unordered = Options.unordered.read(parsedOptions);
+  bool unorderedLibraries =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedLibraryDependencies =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedAdditionalExports =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedParts =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedTypedefs =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedClasses =
+      unordered || Options.unorderedLibraries.read(parsedOptions);
+  bool unorderedMembers =
+      unordered || Options.unorderedMembers.read(parsedOptions);
+  bool unorderedFields =
+      unorderedMembers || Options.unorderedFields.read(parsedOptions);
+  bool unorderedProcedures =
+      unorderedMembers || Options.unorderedProcedures.read(parsedOptions);
+  bool unorderedConstructors =
+      unorderedMembers || Options.unorderedConstructors.read(parsedOptions);
+  bool unorderedAnnotations =
+      unordered || Options.unorderedAnnotations.read(parsedOptions);
+
+  Component dill1 = CommandLineHelper.tryLoadDill(parsedOptions.arguments[0]);
+  Component dill2 = CommandLineHelper.tryLoadDill(parsedOptions.arguments[1]);
+  EquivalenceResult result = checkEquivalence(dill1, dill2,
+      strategy: new Strategy(
+          unorderedLibraries: unorderedLibraries,
+          unorderedLibraryDependencies: unorderedLibraryDependencies,
+          unorderedAdditionalExports: unorderedAdditionalExports,
+          unorderedParts: unorderedParts,
+          unorderedTypedefs: unorderedTypedefs,
+          unorderedClasses: unorderedClasses,
+          unorderedFields: unorderedFields,
+          unorderedProcedures: unorderedProcedures,
+          unorderedConstructors: unorderedConstructors,
+          unorderedAnnotations: unorderedAnnotations));
+  if (result.isEquivalent) {
+    print('The dills are equivalent.');
+  } else {
+    print('Inequivalence found:');
+    print(result);
+  }
+}
+
+EquivalenceResult checkNodeEquivalence(
+  Node node1,
+  Node node2, {
+  bool unorderedLibraries = false,
+  bool unorderedLibraryDependencies = false,
+  bool unorderedAdditionalExports = false,
+  bool unorderedParts = false,
+  bool unorderedTypedefs = false,
+  bool unorderedClasses = false,
+  bool unorderedFields = false,
+  bool unorderedProcedures = false,
+  bool unorderedConstructors = false,
+  bool unorderedAnnotations = false,
+}) {
+  return checkEquivalence(node1, node2,
+      strategy: new Strategy(
+          unorderedLibraries: unorderedLibraries,
+          unorderedLibraryDependencies: unorderedLibraryDependencies,
+          unorderedAdditionalExports: unorderedAdditionalExports,
+          unorderedParts: unorderedParts,
+          unorderedTypedefs: unorderedTypedefs,
+          unorderedClasses: unorderedClasses,
+          unorderedFields: unorderedFields,
+          unorderedProcedures: unorderedProcedures,
+          unorderedConstructors: unorderedConstructors,
+          unorderedAnnotations: unorderedAnnotations));
+}
+
+class Strategy extends EquivalenceStrategy {
+  final bool unorderedLibraries;
+  final bool unorderedLibraryDependencies;
+  final bool unorderedAdditionalExports;
+  final bool unorderedParts;
+  final bool unorderedTypedefs;
+  final bool unorderedClasses;
+  final bool unorderedFields;
+  final bool unorderedProcedures;
+  final bool unorderedConstructors;
+  final bool unorderedAnnotations;
+
+  Strategy(
+      {required this.unorderedLibraries,
+      required this.unorderedLibraryDependencies,
+      required this.unorderedAdditionalExports,
+      required this.unorderedParts,
+      required this.unorderedTypedefs,
+      required this.unorderedClasses,
+      required this.unorderedFields,
+      required this.unorderedProcedures,
+      required this.unorderedConstructors,
+      required this.unorderedAnnotations});
+
+  @override
+  bool checkComponent_libraries(
+      EquivalenceVisitor visitor, Component node, Component other) {
+    if (unorderedLibraries) {
+      return visitor.checkSets(node.libraries.toSet(), other.libraries.toSet(),
+          visitor.matchNamedNodes, visitor.checkNodes, 'libraries');
+    } else {
+      return visitor.checkLists(
+          node.libraries, other.libraries, visitor.checkNodes, 'libraries');
+    }
+  }
+
+  @override
+  bool checkLibrary_dependencies(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedLibraryDependencies) {
+      return visitor
+          .checkSets(node.dependencies.toSet(), other.dependencies.toSet(),
+              (LibraryDependency dependency1, LibraryDependency dependency2) {
+        return visitor.matchReferences(dependency1.importedLibraryReference,
+                dependency2.importedLibraryReference) &&
+            dependency1.flags == dependency2.flags &&
+            dependency1.name == dependency2.name &&
+            dependency1.fileOffset == dependency2.fileOffset;
+      }, visitor.checkNodes, 'dependencies');
+    } else {
+      return visitor.checkLists(node.dependencies, other.dependencies,
+          visitor.checkNodes, 'dependencies');
+    }
+  }
+
+  @override
+  bool checkLibrary_parts(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedParts) {
+      return visitor.checkSets(node.parts.toSet(), other.parts.toSet(),
+          (LibraryPart part1, LibraryPart part2) {
+        return part1.partUri == part2.partUri;
+      }, visitor.checkNodes, 'parts');
+    } else {
+      return visitor.checkLists(
+          node.parts, other.parts, visitor.checkNodes, 'parts');
+    }
+  }
+
+  @override
+  bool checkLibrary_typedefs(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedTypedefs) {
+      return visitor.checkSets(node.typedefs.toSet(), other.typedefs.toSet(),
+          visitor.matchNamedNodes, visitor.checkNodes, 'typedefs');
+    } else {
+      return visitor.checkLists(
+          node.typedefs, other.typedefs, visitor.checkNodes, 'typedefs');
+    }
+  }
+
+  @override
+  bool checkLibrary_additionalExports(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedAdditionalExports) {
+      return visitor.checkSets(
+          node.additionalExports.toSet(),
+          other.additionalExports.toSet(),
+          visitor.matchReferences,
+          visitor.checkReferences,
+          'additionalExports');
+    } else {
+      return visitor.checkLists(node.additionalExports, other.additionalExports,
+          visitor.checkReferences, 'additionalExports');
+    }
+  }
+
+  @override
+  bool checkLibrary_classes(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedClasses) {
+      return visitor.checkSets(node.classes.toSet(), other.classes.toSet(),
+          visitor.matchNamedNodes, visitor.checkNodes, 'classes');
+    } else {
+      return visitor.checkLists(
+          node.classes, other.classes, visitor.checkNodes, 'classes');
+    }
+  }
+
+  @override
+  bool checkLibrary_fields(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedFields) {
+      return visitor.checkSets(node.fields.toSet(), other.fields.toSet(),
+          visitor.matchNamedNodes, visitor.checkNodes, 'fields');
+    } else {
+      return visitor.checkLists(
+          node.fields, other.fields, visitor.checkNodes, 'fields');
+    }
+  }
+
+  @override
+  bool checkLibrary_procedures(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedProcedures) {
+      return visitor.checkSets(
+          node.procedures.toSet(),
+          other.procedures.toSet(),
+          visitor.matchNamedNodes,
+          visitor.checkNodes,
+          'procedures');
+    } else {
+      return visitor.checkLists(
+          node.procedures, other.procedures, visitor.checkNodes, 'procedures');
+    }
+  }
+
+  @override
+  bool checkLibrary_annotations(
+      EquivalenceVisitor visitor, Library node, Library other) {
+    if (unorderedAnnotations) {
+      return visitor.checkSets(
+          node.annotations.toSet(),
+          other.annotations.toSet(),
+          _matchAnnotations,
+          visitor.checkNodes,
+          'annotations');
+    } else {
+      return visitor.checkLists(node.annotations, other.annotations,
+          visitor.checkNodes, 'annotations');
+    }
+  }
+
+  @override
+  bool checkClass_fields(EquivalenceVisitor visitor, Class node, Class other) {
+    if (unorderedFields) {
+      return visitor.checkSets(node.fields.toSet(), other.fields.toSet(),
+          visitor.matchNamedNodes, visitor.checkNodes, 'fields');
+    } else {
+      return visitor.checkLists(
+          node.fields, other.fields, visitor.checkNodes, 'fields');
+    }
+  }
+
+  @override
+  bool checkClass_procedures(
+      EquivalenceVisitor visitor, Class node, Class other) {
+    if (unorderedProcedures) {
+      return visitor.checkSets(
+          node.procedures.toSet(),
+          other.procedures.toSet(),
+          visitor.matchNamedNodes,
+          visitor.checkNodes,
+          'procedures');
+    } else {
+      return visitor.checkLists(
+          node.procedures, other.procedures, visitor.checkNodes, 'procedures');
+    }
+  }
+
+  @override
+  bool checkClass_constructors(
+      EquivalenceVisitor visitor, Class node, Class other) {
+    if (unorderedConstructors) {
+      return visitor.checkSets(
+          node.constructors.toSet(),
+          other.constructors.toSet(),
+          visitor.matchNamedNodes,
+          visitor.checkNodes,
+          'constructors');
+    } else {
+      return visitor.checkLists(node.constructors, other.constructors,
+          visitor.checkNodes, 'constructors');
+    }
+  }
+
+  @override
+  bool checkClass_annotations(
+      EquivalenceVisitor visitor, Class node, Class other) {
+    if (unorderedAnnotations) {
+      return visitor.checkSets(
+          node.annotations.toSet(),
+          other.annotations.toSet(),
+          _matchAnnotations,
+          visitor.checkNodes,
+          'annotations');
+    } else {
+      return visitor.checkLists(node.annotations, other.annotations,
+          visitor.checkNodes, 'annotations');
+    }
+  }
+
+  @override
+  bool checkExtension_annotations(
+      EquivalenceVisitor visitor, Extension node, Extension other) {
+    if (unorderedAnnotations) {
+      return visitor.checkSets(
+          node.annotations.toSet(),
+          other.annotations.toSet(),
+          _matchAnnotations,
+          visitor.checkNodes,
+          'annotations');
+    } else {
+      return visitor.checkLists(node.annotations, other.annotations,
+          visitor.checkNodes, 'annotations');
+    }
+  }
+
+  @override
+  bool checkMember_annotations(
+      EquivalenceVisitor visitor, Member node, Member other) {
+    if (unorderedAnnotations) {
+      return visitor.checkSets(
+          node.annotations.toSet(),
+          other.annotations.toSet(),
+          _matchAnnotations,
+          visitor.checkNodes,
+          'annotations');
+    } else {
+      return visitor.checkLists(node.annotations, other.annotations,
+          visitor.checkNodes, 'annotations');
+    }
+  }
+
+  bool _matchAnnotations(Expression expression1, Expression expression2) {
+    return expression1.runtimeType == expression2.runtimeType &&
+        expression1.fileOffset == expression2.fileOffset;
+  }
+}
+
+class Flags {
+  static const String unordered = '--unordered';
+  static const String unorderedLibraries = '--unordered-libraries';
+  static const String unorderedLibraryDependencies =
+      '--unordered-library-dependencies';
+  static const String unorderedParts = '--unordered-parts';
+  static const String unorderedAdditionalExports =
+      '--unordered-additional-exports';
+  static const String unorderedTypedefs = '--unordered-typedefs';
+  static const String unorderedClasses = '--unordered-classes';
+  static const String unorderedMembers = '--unordered-members';
+  static const String unorderedFields = '--unordered-fields';
+  static const String unorderedProcedures = '--unordered-procedures';
+  static const String unorderedConstructors = '--unordered-constructors';
+  static const String unorderedAnnotations = '--unordered-annotations';
+}
+
+class Options {
+  static const Option<bool> unordered =
+      const Option(Flags.unordered, const BoolValue(false));
+  static const Option<bool> unorderedLibraries =
+      const Option(Flags.unorderedLibraries, const BoolValue(false));
+  static const Option<bool> unorderedLibraryDependencies =
+      const Option(Flags.unorderedLibraryDependencies, const BoolValue(false));
+  static const Option<bool> unorderedParts =
+      const Option(Flags.unorderedParts, const BoolValue(false));
+  static const Option<bool> unorderedAdditionalExports =
+      const Option(Flags.unorderedAdditionalExports, const BoolValue(false));
+  static const Option<bool> unorderedTypedefs =
+      const Option(Flags.unorderedTypedefs, const BoolValue(false));
+  static const Option<bool> unorderedClasses =
+      const Option(Flags.unorderedClasses, const BoolValue(false));
+  static const Option<bool> unorderedMembers =
+      const Option(Flags.unorderedMembers, const BoolValue(false));
+  static const Option<bool> unorderedFields =
+      const Option(Flags.unorderedFields, const BoolValue(false));
+  static const Option<bool> unorderedProcedures =
+      const Option(Flags.unorderedProcedures, const BoolValue(false));
+  static const Option<bool> unorderedConstructors =
+      const Option(Flags.unorderedConstructors, const BoolValue(false));
+  static const Option<bool> unorderedAnnotations =
+      const Option(Flags.unorderedAnnotations, const BoolValue(false));
+}
+
+const List<Option> optionSpecification = [
+  Options.unordered,
+  Options.unorderedLibraries,
+  Options.unorderedLibraryDependencies,
+  Options.unorderedParts,
+  Options.unorderedAdditionalExports,
+  Options.unorderedTypedefs,
+  Options.unorderedClasses,
+  Options.unorderedMembers,
+  Options.unorderedFields,
+  Options.unorderedProcedures,
+  Options.unorderedConstructors,
+  Options.unorderedAnnotations,
+];
diff --git a/pkg/kernel/test/check_equivalence_test.dart b/pkg/kernel/test/check_equivalence_test.dart
new file mode 100644
index 0000000..4996076
--- /dev/null
+++ b/pkg/kernel/test/check_equivalence_test.dart
@@ -0,0 +1,390 @@
+// Copyright (c) 2025, 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.
+
+import 'package:expect/expect.dart';
+import 'package:kernel/ast.dart';
+import 'package:kernel/src/equivalence.dart' show EquivalenceResult;
+import 'package:kernel/src/tool/check_equivalence.dart';
+
+Uri fileUri1 = Uri.parse('file://uri1');
+Uri fileUri2 = Uri.parse('file://uri2');
+Uri fileUri3 = Uri.parse('file://uri3');
+Uri importUri1 = Uri.parse('import://uri1');
+Uri importUri2 = Uri.parse('import://uri2');
+Uri importUri3 = Uri.parse('import://uri3');
+
+List<Test> tests = [
+  new Test((_) => new Component()),
+  new Test((_) => new Component()
+    ..libraries.add(new Library(importUri1, fileUri: fileUri1))),
+  new Test((bool first) {
+    return new Component()
+      ..libraries.add(new Library(first ? importUri1 : importUri2,
+          fileUri: first ? fileUri1 : fileUri2))
+      ..libraries.add(new Library(first ? importUri2 : importUri1,
+          fileUri: first ? fileUri2 : fileUri1));
+  }, inequivalence: '''
+Inequivalent nodes
+1: library import://uri1
+2: library import://uri2
+.root
+ Component.libraries[0]
+''', unorderedLibraries: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library library1 = new Library(importUri1, fileUri: fileUri1);
+    Library library2 = new Library(importUri2, fileUri: fileUri2);
+    c.libraries.add(library1);
+    c.libraries.add(library2);
+    library1.dependencies
+      ..add(new LibraryDependency.import(first ? library2 : library1))
+      ..add(new LibraryDependency.import(first ? library1 : library2));
+    return c;
+  }, inequivalence: '''
+Inequivalent references:
+1: Reference to library import://uri2
+2: Reference to library import://uri1
+.root
+ Component.libraries[0]
+  Library(library import://uri1).dependencies[0]
+   LibraryDependency.importedLibraryReference
+Inequivalent references:
+1: Reference to library import://uri1
+2: Reference to library import://uri2
+.root
+ Component.libraries[0]
+  Library(library import://uri1).dependencies[1]
+   LibraryDependency.importedLibraryReference
+''', unorderedLibraryDependencies: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    Field f1 = new Field.immutable(new Name('field1'), fileUri: fileUri1);
+    l.addField(f1);
+    Field f2 = new Field.immutable(new Name('field2'), fileUri: fileUri1);
+    l.addField(f2);
+    l.additionalExports.add(first ? f1.getterReference : f2.getterReference);
+    l.additionalExports.add(first ? f2.getterReference : f1.getterReference);
+    return c;
+  }, inequivalence: '''
+Inequivalent references:
+1: Reference to field1
+2: Reference to field2
+.root
+ Component.libraries[0]
+  Library(library import://uri1).additionalExports[0]
+''', unorderedAdditionalExports: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    l.parts
+      ..add(new LibraryPart([], first ? '${fileUri2}' : '${fileUri3}')
+        ..parent = l)
+      ..add(new LibraryPart([], first ? '${fileUri3}' : '${fileUri2}')
+        ..parent = l);
+    return c;
+  }, inequivalence: '''
+Values file://uri2/ and file://uri3/ are not equivalent
+.root
+ Component.libraries[0]
+  Library(library import://uri1).parts[0]
+   LibraryPart.partUri
+Values file://uri3/ and file://uri2/ are not equivalent
+.root
+ Component.libraries[0]
+  Library(library import://uri1).parts[1]
+   LibraryPart.partUri
+''', unorderedParts: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    l
+      ..addTypedef(new Typedef(
+          first ? 'Typedef1' : 'Typedef2', const DynamicType(),
+          fileUri: fileUri1))
+      ..addTypedef(new Typedef(
+          first ? 'Typedef2' : 'Typedef1', const DynamicType(),
+          fileUri: fileUri1));
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: Typedef(Typedef1)
+2: Typedef(Typedef2)
+.root
+ Component.libraries[0]
+  Library(library import://uri1).typedefs[0]
+''', unorderedTypedefs: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    l
+      ..addClass(
+          new Class(name: first ? 'Class1' : 'Class2', fileUri: fileUri1))
+      ..addClass(
+          new Class(name: first ? 'Class2' : 'Class1', fileUri: fileUri1));
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: Class(Class1)
+2: Class(Class2)
+.root
+ Component.libraries[0]
+  Library(library import://uri1).classes[0]
+''', unorderedClasses: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    Field f1 = new Field.immutable(new Name('field1'), fileUri: fileUri1);
+    Field f2 = new Field.immutable(new Name('field2'), fileUri: fileUri1);
+    l.addField(first ? f1 : f2);
+    l.addField(first ? f2 : f1);
+    Class cls = new Class(name: first ? 'Class' : 'Class', fileUri: fileUri1);
+    l.addClass(cls);
+    Field f3 = new Field.immutable(new Name('field3'), fileUri: fileUri1);
+    Field f4 = new Field.immutable(new Name('field4'), fileUri: fileUri1);
+    cls.addField(first ? f3 : f4);
+    cls.addField(first ? f4 : f3);
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: Class.field3
+2: Class.field4
+.root
+ Component.libraries[0]
+  Library(library import://uri1).classes[0]
+   Class(Class).fields[0]
+Inequivalent nodes
+1: field1
+2: field2
+.root
+ Component.libraries[0]
+  Library(library import://uri1).fields[0]
+''', unorderedFields: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    Procedure p1 = new Procedure(
+        new Name('procedure1'), ProcedureKind.Method, new FunctionNode(null),
+        fileUri: fileUri1);
+    Procedure p2 = new Procedure(
+        new Name('procedure2'), ProcedureKind.Method, new FunctionNode(null),
+        fileUri: fileUri1);
+    l.addProcedure(first ? p1 : p2);
+    l.addProcedure(first ? p2 : p1);
+    Class cls = new Class(name: first ? 'Class' : 'Class', fileUri: fileUri1);
+    l.addClass(cls);
+    Procedure p3 = new Procedure(
+        new Name('procedure3'), ProcedureKind.Method, new FunctionNode(null),
+        fileUri: fileUri1);
+    Procedure p4 = new Procedure(
+        new Name('procedure4'), ProcedureKind.Method, new FunctionNode(null),
+        fileUri: fileUri1);
+    cls.addProcedure(first ? p3 : p4);
+    cls.addProcedure(first ? p4 : p3);
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: Class.procedure3
+2: Class.procedure4
+.root
+ Component.libraries[0]
+  Library(library import://uri1).classes[0]
+   Class(Class).procedures[0]
+Inequivalent nodes
+1: procedure1
+2: procedure2
+.root
+ Component.libraries[0]
+  Library(library import://uri1).procedures[0]
+''', unorderedProcedures: true),
+  new Test((bool first) {
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    Class cls = new Class(name: first ? 'Class' : 'Class', fileUri: fileUri1);
+    l.addClass(cls);
+    Constructor c1 = new Constructor(new FunctionNode(null),
+        name: new Name('constructor1'), fileUri: fileUri1);
+    Constructor c2 = new Constructor(new FunctionNode(null),
+        name: new Name('constructor2'), fileUri: fileUri1);
+    cls.addConstructor(first ? c1 : c2);
+    cls.addConstructor(first ? c2 : c1);
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: Class.constructor1
+2: Class.constructor2
+.root
+ Component.libraries[0]
+  Library(library import://uri1).classes[0]
+   Class(Class).constructors[0]
+''', unorderedConstructors: true),
+  new Test((bool first) {
+    Expression createAnnotation1() =>
+        first ? new IntLiteral(0) : new StringLiteral("foo");
+    Expression createAnnotation2() =>
+        first ? new StringLiteral("foo") : new IntLiteral(0);
+
+    Component c = new Component();
+    Library l = new Library(importUri1, fileUri: fileUri1);
+    c.libraries.add(l);
+    l
+      ..addAnnotation(createAnnotation1())
+      ..addAnnotation(createAnnotation2());
+    Class cls = new Class(name: first ? 'Class' : 'Class', fileUri: fileUri1);
+    l.addClass(cls);
+    cls
+      ..addAnnotation(createAnnotation1())
+      ..addAnnotation(createAnnotation2());
+    Procedure p = new Procedure(
+        new Name('procedure'), ProcedureKind.Method, new FunctionNode(null),
+        fileUri: fileUri1);
+    l.addProcedure(p);
+    p
+      ..addAnnotation(createAnnotation1())
+      ..addAnnotation(createAnnotation2());
+    return c;
+  }, inequivalence: '''
+Inequivalent nodes
+1: IntLiteral(0)
+2: StringLiteral("foo")
+.root
+ Component.libraries[0]
+  Library(library import://uri1).annotations[0]
+Inequivalent nodes
+1: IntLiteral(0)
+2: StringLiteral("foo")
+.root
+ Component.libraries[0]
+  Library(library import://uri1).classes[0]
+   Class(Class).annotations[0]
+Inequivalent nodes
+1: IntLiteral(0)
+2: StringLiteral("foo")
+.root
+ Component.libraries[0]
+  Library(library import://uri1).procedures[0]
+   Procedure(procedure).annotations[0]
+''', unorderedAnnotations: true),
+];
+
+class Test {
+  final Node a;
+  final Node b;
+  final String? inequivalence;
+  final bool? unorderedLibraries;
+  final bool? unorderedLibraryDependencies;
+  final bool? unorderedAdditionalExports;
+  final bool? unorderedParts;
+  final bool? unorderedTypedefs;
+  final bool? unorderedClasses;
+  final bool? unorderedFields;
+  final bool? unorderedProcedures;
+  final bool? unorderedConstructors;
+  final bool? unorderedAnnotations;
+
+  Test(
+    Node Function(bool) create, {
+    this.inequivalence,
+    this.unorderedLibraries,
+    this.unorderedLibraryDependencies,
+    this.unorderedAdditionalExports,
+    this.unorderedParts,
+    this.unorderedTypedefs,
+    this.unorderedClasses,
+    this.unorderedFields,
+    this.unorderedProcedures,
+    this.unorderedConstructors,
+    this.unorderedAnnotations,
+  })  : a = create(true),
+        b = create(false);
+
+  bool get isEquivalent => inequivalence == null;
+
+  String get options {
+    List<String> list = [];
+    if (unorderedLibraries != null) {
+      list.add('unorderedLibraries=$unorderedLibraries');
+    }
+    if (unorderedLibraryDependencies != null) {
+      list.add('unorderedLibraryDependencies=$unorderedLibraryDependencies');
+    }
+    if (unorderedAdditionalExports != null) {
+      list.add('unorderedAdditionalExports=$unorderedAdditionalExports');
+    }
+    if (unorderedParts != null) {
+      list.add('unorderedParts=$unorderedParts');
+    }
+    if (unorderedTypedefs != null) {
+      list.add('unorderedTypedefs=$unorderedTypedefs');
+    }
+    if (unorderedClasses != null) {
+      list.add('unorderedClasses=$unorderedClasses');
+    }
+    if (unorderedFields != null) {
+      list.add('unorderedFields=$unorderedFields');
+    }
+    if (unorderedProcedures != null) {
+      list.add('unorderedProcedures=$unorderedProcedures');
+    }
+    if (unorderedConstructors != null) {
+      list.add('unorderedConstructors=$unorderedConstructors');
+    }
+    if (unorderedAnnotations != null) {
+      list.add('unorderedAnnotations=$unorderedAnnotations');
+    }
+    return list.join(',');
+  }
+}
+
+void main() {
+  for (Test test in tests) {
+    EquivalenceResult result = checkNodeEquivalence(test.a, test.b);
+    if (test.isEquivalent) {
+      Expect.equals(result.isEquivalent, test.isEquivalent,
+          'Unexpected result for\n${test.a}\n${test.b}:\n$result');
+      Expect.equals(
+          '', test.options, 'Unexpected options for\n${test.a}\n${test.b}.');
+    } else if (result.isEquivalent) {
+      Expect.equals(
+          result.isEquivalent,
+          test.isEquivalent,
+          'Unexpected equivalence for\n${test.a}\n${test.b}:\n'
+          'Expected ${test.inequivalence}');
+    } else {
+      Expect.stringEquals(
+          result.toString(),
+          test.inequivalence!,
+          'Unexpected inequivalence result for\n${test.a}\n${test.b}:\n'
+          'Expected:\n---\n${test.inequivalence}\n---\n'
+          'Actual:\n---\n${result}\n---');
+
+      EquivalenceResult optionResult = checkNodeEquivalence(
+        test.a,
+        test.b,
+        unorderedLibraries: test.unorderedLibraries ?? false,
+        unorderedLibraryDependencies:
+            test.unorderedLibraryDependencies ?? false,
+        unorderedAdditionalExports: test.unorderedAdditionalExports ?? false,
+        unorderedParts: test.unorderedParts ?? false,
+        unorderedTypedefs: test.unorderedTypedefs ?? false,
+        unorderedClasses: test.unorderedClasses ?? false,
+        unorderedFields: test.unorderedFields ?? false,
+        unorderedProcedures: test.unorderedProcedures ?? false,
+        unorderedConstructors: test.unorderedConstructors ?? false,
+        unorderedAnnotations: test.unorderedAnnotations ?? false,
+      );
+      Expect.isTrue(
+          optionResult.isEquivalent,
+          'Unexpected result for\n${test.a}\n${test.b} with ${test.options}:\n'
+          '$optionResult');
+    }
+  }
+}