diff --git a/pkg/front_end/test/fasta/expression_suite.dart b/pkg/front_end/test/fasta/expression_suite.dart
index 8ada32c..8e867b7 100644
--- a/pkg/front_end/test/fasta/expression_suite.dart
+++ b/pkg/front_end/test/fasta/expression_suite.dart
@@ -38,7 +38,17 @@
     show IncrementalCompiler;
 
 import "package:kernel/ast.dart"
-    show Component, DartType, DynamicType, Procedure, TypeParameter;
+    show
+        Class,
+        Component,
+        Constructor,
+        DartType,
+        DynamicType,
+        Field,
+        Library,
+        Member,
+        Procedure,
+        TypeParameter;
 
 import 'package:kernel/target/targets.dart' show TargetFlags;
 
@@ -65,7 +75,11 @@
   @override
   final List<Step> steps;
 
-  Context(this.compilerContext, this.errors, bool updateExpectations)
+  final bool fuzz;
+  final Set<Uri> fuzzedLibraries = {};
+  int fuzzCompiles = 0;
+
+  Context(this.compilerContext, this.errors, bool updateExpectations, this.fuzz)
       : steps = <Step>[
           const ReadTest(),
           const CompileExpression(),
@@ -399,6 +413,118 @@
       List<int> list = serializeProcedure(compiledProcedure);
       assert(list.length > 0);
     }
+
+    if (context.fuzz) {
+      await fuzz(compiler, compilerResult, context);
+    }
+  }
+
+  Future<void> fuzz(IncrementalCompiler compiler,
+      IncrementalCompilerResult compilerResult, Context context) async {
+    for (Library lib in compilerResult.classHierarchy!.knownLibraries) {
+      if (!context.fuzzedLibraries.add(lib.importUri)) continue;
+
+      for (Member m in lib.members) {
+        await fuzzMember(m, compiler, lib.importUri, context);
+      }
+
+      for (Class c in lib.classes) {
+        for (Member m in c.members) {
+          await fuzzMember(m, compiler, lib.importUri, context);
+        }
+      }
+    }
+  }
+
+  Future<void> fuzzMember(Member m, IncrementalCompiler compiler,
+      Uri libraryUri, Context context) async {
+    String expression = m.name.text;
+    if (m is Field || (m is Procedure && m.isGetter)) {
+      // fields and getters are fine as-is
+    } else if (m is Procedure && !m.isGetter) {
+      expression = "$expression()";
+    } else if (m is Constructor) {
+      if (m.parent is! Class) {
+        return;
+      }
+      Class parent = m.parent as Class;
+      if (m.name.text != "") {
+        expression = "${parent.name}.${m.name.text}()";
+      } else {
+        expression = "${parent.name}()";
+      }
+    } else {
+      print("Ignoring $m (${m.runtimeType})");
+      return;
+    }
+
+    String? className;
+    if (m.parent is Class && m is! Constructor) {
+      Class parent = m.parent as Class;
+      className = parent.name;
+    }
+
+    await fuzzTryCompile(compiler, "$expression", libraryUri, className,
+        !m.isInstanceMember, context);
+    if (className != null && !m.isInstanceMember) {
+      await fuzzTryCompile(compiler, "$className.$expression", libraryUri, null,
+          !m.isInstanceMember, context);
+    }
+    await fuzzTryCompile(compiler, "$expression.toString()", libraryUri,
+        className, !m.isInstanceMember, context);
+    if (className != null && !m.isInstanceMember) {
+      await fuzzTryCompile(compiler, "$className.$expression.toString()",
+          libraryUri, null, !m.isInstanceMember, context);
+    }
+    await fuzzTryCompile(compiler, "$expression.toString() == '42'", libraryUri,
+        className, !m.isInstanceMember, context);
+    if (className != null && !m.isInstanceMember) {
+      await fuzzTryCompile(
+          compiler,
+          "$className.$expression.toString() == '42'",
+          libraryUri,
+          null,
+          !m.isInstanceMember,
+          context);
+    }
+    await fuzzTryCompile(
+        compiler,
+        "() { var x = $expression.toString(); x == '42'; }()",
+        libraryUri,
+        className,
+        !m.isInstanceMember,
+        context);
+    if (className != null && !m.isInstanceMember) {
+      await fuzzTryCompile(
+          compiler,
+          "() { var x = $className.$expression.toString(); x == '42'; }()",
+          libraryUri,
+          null,
+          !m.isInstanceMember,
+          context);
+    }
+  }
+
+  Future<void> fuzzTryCompile(IncrementalCompiler compiler, String expression,
+      Uri libraryUri, String? className, bool isStatic, Context context) async {
+    context.fuzzCompiles++;
+    print("Fuzz compile #${context.fuzzCompiles} "
+        "('$expression' in $libraryUri $className)");
+    Procedure? compiledProcedure = await compiler.compileExpression(
+      expression,
+      {},
+      [],
+      "debugExpr",
+      libraryUri,
+      className: className,
+      isStatic: isStatic,
+    );
+    context.takeErrors();
+    if (compiledProcedure != null) {
+      // Confirm we can serialize generated procedure.
+      List<int> list = serializeProcedure(compiledProcedure);
+      assert(list.length > 0);
+    }
   }
 
   @override
@@ -430,6 +556,7 @@
           path: test.entryPoint!.path + ".dill");
       Uint8List dillData = await serializeComponent(component);
       context.fileSystem.entityForUri(dillFileUri).writeAsBytesSync(dillData);
+      Set<Uri> beforeFuzzedLibraries = context.fuzzedLibraries.toSet();
       await compileExpression(
           test, sourceCompiler, sourceCompilerResult, context);
 
@@ -444,6 +571,8 @@
       // Since it compiled successfully from source, the bootstrap-from-Dill
       // should also succeed without errors.
       assert(errors.isEmpty);
+      context.fuzzedLibraries.clear();
+      context.fuzzedLibraries.addAll(beforeFuzzedLibraries);
       await compileExpression(test, dillCompiler, dillCompilerResult, context);
     }
     return new Result.pass(tests);
@@ -492,13 +621,15 @@
 
   final bool updateExpectations = environment["updateExpectations"] == "true";
 
+  final bool fuzz = environment["fuzz"] == "true";
+
   final CompilerContext compilerContext = new CompilerContext(options);
 
   // Disable colors to ensure that expectation files are the same across
   // platforms and independent of stdin/stderr.
   colors.enableColors = false;
 
-  return new Context(compilerContext, errors, updateExpectations);
+  return new Context(compilerContext, errors, updateExpectations, fuzz);
 }
 
 void main([List<String> arguments = const []]) =>
diff --git a/pkg/front_end/test/fasta/tool_git_test.dart b/pkg/front_end/test/fasta/tool_git_test.dart
index 6e4b231..092e026 100644
--- a/pkg/front_end/test/fasta/tool_git_test.dart
+++ b/pkg/front_end/test/fasta/tool_git_test.dart
@@ -114,7 +114,7 @@
     "dump-ir": {
       "exitCode": 2,
       "stdout": "",
-      "stderr": "Usage: dump-ir dillfile [output]\n",
+      "stderr": "Usage: dump-ir dillFile [output]\n",
     },
   };
 
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 2fe783e..5226583 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -28,6 +28,7 @@
 affecting
 afterwards
 agree
+agreeing
 ahe
 ai
 aiki
@@ -174,6 +175,7 @@
 char
 charcode
 chars
+checkout
 checkpoint
 chloestefantsova
 chunks
@@ -492,6 +494,7 @@
 futureor
 g
 gardening
+gb
 gen
 generation
 getable
@@ -560,6 +563,7 @@
 ideographic
 idn
 ids
+idx
 iff
 il
 imitate
@@ -652,6 +656,7 @@
 jvm
 k
 kallentu
+kb
 kernel's
 kill
 klass
@@ -766,6 +771,7 @@
 nameless
 namer
 natively
+nativewrappers
 nbsp
 nc
 ncs
@@ -836,6 +842,7 @@
 overlooked
 overshadowed
 oversight
+overview
 overwrite
 overwriting
 ownership
@@ -1178,6 +1185,7 @@
 starter
 stated
 statics
+stats
 stderr
 stdin
 stdio
@@ -1452,6 +1460,7 @@
 xdc
 xdfff
 xef
+xff
 xi
 xj
 xk
diff --git a/pkg/front_end/test/spell_checking_list_tests.txt b/pkg/front_end/test/spell_checking_list_tests.txt
index 33568c9..3300b99 100644
--- a/pkg/front_end/test/spell_checking_list_tests.txt
+++ b/pkg/front_end/test/spell_checking_list_tests.txt
@@ -188,6 +188,7 @@
 descriptors
 deviation
 dfast
+dfuzz
 di
 diagnosticable
 dictionaries
@@ -195,7 +196,6 @@
 differentiate
 dijkstra
 dijkstras
-dillfile
 dinteractive
 dirname
 disagree
diff --git a/pkg/front_end/test/weekly_tester.dart b/pkg/front_end/test/weekly_tester.dart
index 2fe9bbf..077210e 100644
--- a/pkg/front_end/test/weekly_tester.dart
+++ b/pkg/front_end/test/weekly_tester.dart
@@ -124,6 +124,24 @@
     }
   }
 
+  {
+    // Expression suite with fuzzing.
+    Uri expressionSuite =
+        Platform.script.resolve("fasta/expression_suite.dart");
+    if (!new File.fromUri(expressionSuite).existsSync()) {
+      exitCode = 1;
+      print("Couldn't find $expressionSuite");
+    } else {
+      startedProcesses.add(await run(
+        [
+          expressionSuite.toString(),
+          "-Dfuzz=true",
+        ],
+        "expression suite",
+      ));
+    }
+  }
+
   // Wait for everything to finish.
   List<int> exitCodes =
       await Future.wait(startedProcesses.map((e) => e.process.exitCode));
diff --git a/pkg/front_end/testing.json b/pkg/front_end/testing.json
index 9b60daf..81a46c2 100644
--- a/pkg/front_end/testing.json
+++ b/pkg/front_end/testing.json
@@ -319,7 +319,8 @@
       "pattern": [
         "_fe_analyzer_shared/lib/.*\\.dart$",
         "front_end/lib/.*\\.dart$",
-        "kernel/lib/.*\\.dart$"
+        "kernel/lib/.*\\.dart$",
+        "kernel/bin/.*\\.dart$"
       ],
       "exclude": [
         "kernel/lib/vm/.*\\.dart$",
diff --git a/pkg/front_end/tool/fasta b/pkg/front_end/tool/fasta
index 29d5544..1a3d971 100755
--- a/pkg/front_end/tool/fasta
+++ b/pkg/front_end/tool/fasta
@@ -46,7 +46,7 @@
       set -- "$@" /dev/fd/1
     fi
     if [ "$#" != "3" ]; then
-      stop "Usage: $1 dillfile [output]"
+      stop "Usage: $1 dillFile [output]"
     fi
     ;;
   testing)
diff --git a/pkg/front_end/tool/fasta.dart b/pkg/front_end/tool/fasta.dart
index 3e02026..14f8503 100644
--- a/pkg/front_end/tool/fasta.dart
+++ b/pkg/front_end/tool/fasta.dart
@@ -63,7 +63,7 @@
     case 'dump-ir':
       script = '${kernelBin}/dump.dart';
       if (remainingArguments.isEmpty || remainingArguments.length > 2) {
-        stop("Usage: $command dillfile [output]");
+        stop("Usage: $command dillFile [output]");
       }
       break;
     case 'testing':
diff --git a/pkg/kernel/bin/compare_hierarchies.dart b/pkg/kernel/bin/compare_hierarchies.dart
new file mode 100644
index 0000000..e6e35ca
--- /dev/null
+++ b/pkg/kernel/bin/compare_hierarchies.dart
@@ -0,0 +1,163 @@
+#!/usr/bin/env dart
+// Copyright (c) 2022, 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:kernel/class_hierarchy.dart';
+import 'package:kernel/core_types.dart';
+import 'package:kernel/kernel.dart';
+import 'package:kernel/src/tool/command_line_util.dart';
+
+void usage() {
+  print("Compares the hierarchies of two dill files.");
+  print("");
+  print("Usage: dart <script> dillFile1.dill dillFile2.dill "
+      "[import:uri#classToIgnore|another:uri#andClassToIgnore]");
+  exit(1);
+}
+
+void main(List<String> args) {
+  CommandLineHelper.requireVariableArgumentCount([2, 3], args, usage);
+  CommandLineHelper.requireFileExists(args[0]);
+  CommandLineHelper.requireFileExists(args[1]);
+  Component binary1 = CommandLineHelper.tryLoadDill(args[0]);
+  Component binary2 = CommandLineHelper.tryLoadDill(args[1]);
+  Map<Uri, Set<String>> ignoresMap = {};
+  if (args.length >= 3) {
+    List<String> ignores = args[2].split("|");
+    for (String ignore in ignores) {
+      List<String> uriClassName = ignore.split("#");
+      if (uriClassName.length != 2) {
+        print("Ignoring '$ignore' as it doesn't conform to "
+            "'importUri#className'");
+        continue;
+      }
+      Uri uri = Uri.parse(uriClassName[0]);
+      String className = uriClassName[1];
+      (ignoresMap[uri] ??= {}).add(className);
+    }
+  }
+
+  print("(1): ${args[0]}");
+  print("(2): ${args[1]}");
+  print("");
+
+  ClosedWorldClassHierarchy ch1 =
+      new ClassHierarchy(binary1, new CoreTypes(binary1))
+          as ClosedWorldClassHierarchy;
+  ClosedWorldClassHierarchy ch2 =
+      new ClassHierarchy(binary2, new CoreTypes(binary2))
+          as ClosedWorldClassHierarchy;
+
+  Map<Uri, Library> libMap1 = createLibMap(binary1);
+  Map<Uri, Library> libMap2 = createLibMap(binary2);
+  Set<Uri> agreeingImportUris = new Set<Uri>.from(libMap1.keys)
+    ..retainAll(libMap2.keys);
+
+  for (Uri uri in agreeingImportUris) {
+    Library lib1 = libMap1[uri]!;
+    Library lib2 = libMap2[uri]!;
+    Map<String, Class> libClass1 =
+        createPublicClassMap(lib1, ignored: ignoresMap[uri]);
+    Map<String, Class> libClass2 =
+        createPublicClassMap(lib2, ignored: ignoresMap[uri]);
+    Set<String> agreeingClasses = new Set<String>.from(libClass1.keys)
+      ..retainAll(libClass2.keys);
+    if (agreeingClasses.length != libClass1.length ||
+        libClass1.length != libClass2.length) {
+      print("Missing classes in lib $uri");
+      Set<String> missing = new Set<String>.from(libClass1.keys)
+        ..removeAll(libClass2.keys);
+      if (missing.isNotEmpty) {
+        print("In (1) but not in (2): ${missing.toList()}");
+      }
+      missing = new Set<String>.from(libClass2.keys)..removeAll(libClass1.keys);
+      if (missing.isNotEmpty) {
+        print("In (2) but not in (1): ${missing.toList()}");
+      }
+      print("");
+    }
+
+    for (String className in agreeingClasses) {
+      Class c1 = libClass1[className]!;
+      Class c2 = libClass2[className]!;
+      Set<ClassReference> c1Supertypes = createClassReferenceSet(
+          ch1.getAllSupertypeClassesForTesting(c1),
+          onlyPublic: true,
+          ignoresMap: ignoresMap);
+      Set<ClassReference> c2Supertypes = createClassReferenceSet(
+          ch2.getAllSupertypeClassesForTesting(c2),
+          onlyPublic: true,
+          ignoresMap: ignoresMap);
+      Set<ClassReference> missing = new Set<ClassReference>.from(c1Supertypes)
+        ..removeAll(c2Supertypes);
+      if (missing.isNotEmpty) {
+        print("$c1 in $lib1 from (1) has these extra supertypes: "
+            "${missing.toList()}");
+      }
+      missing = new Set<ClassReference>.from(c2Supertypes)
+        ..removeAll(c1Supertypes);
+      if (missing.isNotEmpty) {
+        print("$c2 in $lib2 from (2) has these extra supertypes: "
+            "${missing.toList()}");
+      }
+    }
+  }
+}
+
+Map<Uri, Library> createLibMap(Component c) {
+  Map<Uri, Library> map = {};
+  for (Library lib in c.libraries) {
+    map[lib.importUri] = lib;
+  }
+  return map;
+}
+
+Map<String, Class> createPublicClassMap(Library lib,
+    {required Set<String>? ignored}) {
+  Map<String, Class> map = {};
+  for (Class c in lib.classes) {
+    if (c.name.startsWith("_")) continue;
+    if (ignored?.contains(c.name) ?? false) continue;
+    map[c.name] = c;
+  }
+  return map;
+}
+
+Set<ClassReference> createClassReferenceSet(List<Class> classes,
+    {required bool onlyPublic, required Map<Uri, Set<String>> ignoresMap}) {
+  Set<ClassReference> result = {};
+  for (Class c in classes) {
+    if (onlyPublic && c.name.startsWith("_")) continue;
+    Set<String>? ignored = ignoresMap[c.enclosingLibrary.importUri];
+    if (ignored?.contains(c.name) ?? false) continue;
+    result.add(new ClassReference(c.name, c.enclosingLibrary.importUri));
+  }
+  return result;
+}
+
+class ClassReference {
+  final String name;
+  final Uri libImportUri;
+
+  const ClassReference(this.name, this.libImportUri);
+
+  @override
+  int get hashCode => name.hashCode * 13 + libImportUri.hashCode * 17;
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    if (other is! ClassReference) return false;
+    if (name != other.name) return false;
+    if (libImportUri != other.libImportUri) return false;
+    return true;
+  }
+
+  @override
+  String toString() {
+    return "$name ($libImportUri)";
+  }
+}
diff --git a/pkg/kernel/bin/dill_forensic.dart b/pkg/kernel/bin/dill_forensic.dart
index c95d02a..b68b32f 100755
--- a/pkg/kernel/bin/dill_forensic.dart
+++ b/pkg/kernel/bin/dill_forensic.dart
@@ -12,16 +12,16 @@
 
 void main(List<String> args) {
   if (args.length != 1) {
-    throw "Usage: dart <script> <dillfile>";
+    throw "Usage: dart <script> <dillFile>";
   }
   File file = new File(args.single);
   if (!file.existsSync()) {
     throw "Given file doesn't exist.\n"
-        "Usage: dart <script> <dillfile>";
+        "Usage: dart <script> <dillFile>";
   }
   Uint8List bytes = file.readAsBytesSync();
   List<Component> components = splitAndRead(bytes);
-  print("Sucessfully read ${components.length} sub-components.");
+  print("Successfully read ${components.length} sub-components.");
 
   for (int i = 0; i < components.length; i++) {
     Component component = components[i];
@@ -77,7 +77,7 @@
   tagOffsets.add(bytes.length);
 
   // Warning: O(n²) algorithm (though, as the tag is assumed to be rather unique
-  // in normal cases it will probably much better in practise
+  // in normal cases it will probably much better in practice
   // (and n will be low)).
   int fromIndex = 0;
   while (fromIndex < tagOffsets.length - 1) {
diff --git a/pkg/kernel/lib/class_hierarchy.dart b/pkg/kernel/lib/class_hierarchy.dart
index cf9320c..440da58 100644
--- a/pkg/kernel/lib/class_hierarchy.dart
+++ b/pkg/kernel/lib/class_hierarchy.dart
@@ -491,6 +491,25 @@
     return result;
   }
 
+  List<Class> getAllSupertypeClassesForTesting(Class class_) {
+    List<Class?> allClassesByIndex =
+        new List<Class?>.filled(_infoMap.length, null);
+    for (MapEntry<Class, _ClassInfo> c in _infoMap.entries) {
+      allClassesByIndex[c.value.topologicalIndex] = c.key;
+    }
+
+    List<Class> result = [];
+    Uint32List list = _infoMap[class_]!.supertypeIntervalList;
+    for (int i = 0; i < list.length; i += 2) {
+      int from = list[i];
+      int to = list[i + 1];
+      for (int j = from; j < to; j++) {
+        result.add(allClassesByIndex[j]!);
+      }
+    }
+    return result;
+  }
+
   _ClassInfo infoFor(Class cls) {
     _ClassInfo? info = _infoMap[cls];
     if (info == null) {
diff --git a/tools/VERSION b/tools/VERSION
index 02fd046..9a2d9f1 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 77
+PRERELEASE 78
 PRERELEASE_PATCH 0
\ No newline at end of file