InvalidatedModuleReport -> ModifiedModuleReport

Author: srujzs

dwds/lib/src/debugging/inspector.dart

@@ -36,8 +36,8 @@ class AppInspector implements AppInspectorInterface {
   var _scriptCacheMemoizer = AsyncMemoizer<List<ScriptRef>>();
 
   Future<List<ScriptRef>> getScriptRefs([
-    InvalidatedModuleReport? invalidatedModuleReport,
-  ]) => _populateScriptCaches(invalidatedModuleReport);
+    ModifiedModuleReport? modifiedModuleReport,
+  ]) => _populateScriptCaches(modifiedModuleReport);
 
   final _logger = Logger('AppInspector');
 
@@ -106,10 +106,8 @@ class AppInspector implements AppInspectorInterface {
 
   /// Reset all caches and recompute any mappings.
   ///
-  /// Should be called across hot reloads with a valid [invalidatedModuleReport].
-  Future<void> initialize([
-    InvalidatedModuleReport? invalidatedModuleReport,
-  ]) async {
+  /// Should be called across hot reloads with a valid [ModifiedModuleReport].
+  Future<void> initialize([ModifiedModuleReport? modifiedModuleReport]) async {
     _scriptCacheMemoizer = AsyncMemoizer<List<ScriptRef>>();
 
     // TODO(srujzs): We can invalidate these in a smarter way instead of
@@ -118,9 +116,9 @@ class AppInspector implements AppInspectorInterface {
     _classHelper = ClassHelper(this);
     _instanceHelper = InstanceHelper(this);
 
-    if (invalidatedModuleReport != null) {
+    if (modifiedModuleReport != null) {
       // Invalidate `_libraryHelper` as we use it populate any script caches.
-      _libraryHelper.invalidate(invalidatedModuleReport);
+      _libraryHelper.invalidate(modifiedModuleReport);
     } else {
       _libraryHelper = LibraryHelper(this);
       _scriptRefsById.clear();
@@ -134,7 +132,7 @@ class AppInspector implements AppInspectorInterface {
     isolate.libraries?.clear();
     isolate.libraries?.addAll(libraries);
 
-    final scripts = await getScriptRefs(invalidatedModuleReport);
+    final scripts = await getScriptRefs(modifiedModuleReport);
 
     await DartUri.initialize();
     DartUri.recordAbsoluteUris(libraries.map((lib) => lib.uri).nonNulls);
@@ -728,25 +726,22 @@ class AppInspector implements AppInspectorInterface {
   ///
   /// This will get repopulated on restarts and reloads.
   ///
-  /// If [invalidatedModuleReport] is provided, only invalidates and
-  /// recalculates caches for the invalidated/new libraries.
+  /// If [modifiedModuleReport] is provided, only invalidates and
+  /// recalculates caches for the modified libraries.
   ///
   /// Returns the list of scripts refs cached.
   Future<List<ScriptRef>> _populateScriptCaches([
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) {
     return _scriptCacheMemoizer.runOnce(() async {
       final scripts =
           await globalToolConfiguration.loadStrategy
               .metadataProviderFor(appConnection.request.entrypointPath)
               .scripts;
-      final invalidatedAndNewLibraries = invalidatedModuleReport
-          ?.deletedLibraries
-          .union(invalidatedModuleReport.reloadedLibraries);
-      if (invalidatedAndNewLibraries != null) {
+      if (modifiedModuleReport != null) {
         // Invalidate any script caches that were computed for the now invalid
         // libraries. They will get repopulated later.
-        for (final libraryUri in invalidatedAndNewLibraries) {
+        for (final libraryUri in modifiedModuleReport.modifiedLibraries) {
           final libraryRef = await _libraryHelper.libraryRefFor(libraryUri);
           final libraryId = libraryRef?.id;
           if (libraryId == null) continue;
@@ -771,8 +766,8 @@ class AppInspector implements AppInspectorInterface {
         isolate.libraries ?? <LibraryRef>[],
       );
       for (final uri in userLibraries) {
-        if (invalidatedAndNewLibraries != null &&
-            !invalidatedAndNewLibraries.contains(uri)) {
+        if (modifiedModuleReport != null &&
+            !modifiedModuleReport.modifiedLibraries.contains(uri)) {
           continue;
         }
         final parts = scripts[uri];

dwds/lib/src/debugging/libraries.dart

@@ -52,16 +52,13 @@ class LibraryHelper extends Domain {
     return _rootLib!;
   }
 
-  void invalidate(InvalidatedModuleReport invalidatedModuleReport) {
-    final invalidatedLibraries = invalidatedModuleReport.deletedLibraries.union(
-      invalidatedModuleReport.reloadedLibraries,
-    );
-    for (final library in invalidatedLibraries) {
+  void invalidate(ModifiedModuleReport modifiedModuleReport) {
+    for (final library in modifiedModuleReport.modifiedLibraries) {
       // These will later be initialized by `libraryFor` if needed.
       _librariesById.remove(library);
       _libraryRefsById.remove(library);
     }
-    for (final library in invalidatedModuleReport.reloadedLibraries) {
+    for (final library in modifiedModuleReport.reloadedLibraries) {
       _libraryRefsById[library] = _createLibraryRef(library);
     }
   }

dwds/lib/src/debugging/location.dart

@@ -154,14 +154,12 @@ class Locations {
 
   Future<void> initialize(
     String entrypoint, [
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {
     // If we know that only certain modules are deleted or added, we can only
     // invalidate those.
-    if (invalidatedModuleReport != null) {
-      for (final module in invalidatedModuleReport.deletedModules.union(
-        invalidatedModuleReport.reloadedModules,
-      )) {
+    if (modifiedModuleReport != null) {
+      for (final module in modifiedModuleReport.modifiedModules) {
         _locationMemoizer.remove(module);
         _moduleToLocations.remove(module);
         final sources = await _modules.sourcesForModule(module);

dwds/lib/src/debugging/metadata/module_metadata.dart

@@ -103,6 +103,8 @@ class ModuleMetadata {
   ///
   /// Used as a name of the js module created by the compiler and
   /// as key to store and load modules in the debugger and the browser
+  // TODO(srujzs): Remove once https://github.com/dart-lang/sdk/issues/59618 is
+  // resolved.
   final String name;
 
   /// Name of the function enclosing the module

dwds/lib/src/debugging/metadata/provider.dart

@@ -202,7 +202,7 @@ class MetadataProvider {
             );
             final moduleName = metadata.name;
             if (hotReload) {
-              modules?[moduleName] = metadata;
+              modules![moduleName] = metadata;
             } else {
               _addMetadata(metadata);
             }
@@ -226,9 +226,9 @@ class MetadataProvider {
   /// determines deleted and invalidated libraries and modules, invalidates them
   /// in any caches, and recomputes the necessary information.
   ///
-  /// Returns an [InvalidatedModuleReport] that can be used to invalidate other
+  /// Returns an [ModifiedModuleReport] that can be used to invalidate other
   /// caches after a hot reload.
-  Future<InvalidatedModuleReport> reinitializeAfterReload(
+  Future<ModifiedModuleReport> reinitializeAfterReload(
     Map<String, List> reloadedModulesToLibraries,
   ) async {
     final modules = (await _processMetadata(true))!;
@@ -271,7 +271,7 @@ class MetadataProvider {
         invalidatedLibraries
             .where((library) => !_libraries.contains(library))
             .toSet();
-    return InvalidatedModuleReport(
+    return ModifiedModuleReport(
       deletedModules: deletedModules,
       deletedLibraries: deletedLibraries,
       reloadedModules: reloadedModules,
@@ -334,10 +334,10 @@ class AbsoluteImportUriException implements Exception {
 /// Computed after a hot reload using
 /// [MetadataProvider.reinitializeAfterReload], represents the modules and
 /// libraries in the program that were deleted, reloaded, and therefore,
-/// invalidated.
+/// modified.
 ///
 /// Used to recompute caches throughout DWDS.
-class InvalidatedModuleReport {
+class ModifiedModuleReport {
   /// Module names that are no longer in the program.
   final Set<String> deletedModules;
 
@@ -349,10 +349,17 @@ class InvalidatedModuleReport {
 
   /// Library uris that were loaded during the hot reload.
   final Set<String> reloadedLibraries;
-  InvalidatedModuleReport({
+
+  /// Module names that were either removed or modified.
+  final Set<String> modifiedModules;
+
+  /// Library uris that were either removed or modified.
+  final Set<String> modifiedLibraries;
+  ModifiedModuleReport({
     required this.deletedModules,
     required this.deletedLibraries,
     required this.reloadedModules,
     required this.reloadedLibraries,
-  });
+  }) : modifiedModules = deletedModules.union(reloadedModules),
+       modifiedLibraries = deletedLibraries.union(reloadedLibraries);
 }

dwds/lib/src/debugging/modules.dart

@@ -34,13 +34,25 @@ class Modules {
   ///
   /// Intended to be called multiple times throughout the development workflow,
   /// e.g. after a hot-reload.
+  ///
+  /// If [modifiedModuleReport] is not null, removes and recalculates caches for
+  /// any modified modules and libraries.
   Future<void> initialize(
     String entrypoint, [
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {
-    if (invalidatedModuleReport != null) {
+    if (modifiedModuleReport != null) {
       assert(_entrypoint == entrypoint);
-      await _initializeMapping(invalidatedModuleReport);
+      for (final library in modifiedModuleReport.modifiedLibraries) {
+        final libraryServerPath = _getLibraryServerPath(library);
+        _sourceToLibrary.remove(libraryServerPath);
+        _sourceToModule.remove(libraryServerPath);
+        _libraryToModule.remove(library);
+      }
+      for (final module in modifiedModuleReport.modifiedModules) {
+        _moduleToSources.remove(module);
+      }
+      await _initializeMapping(modifiedModuleReport);
     } else {
       _sourceToModule.clear();
       _moduleToSources.clear();
@@ -96,34 +108,12 @@ class Modules {
           ? library
           : DartUri(library, _root).serverPath;
 
-  Set<String> _invalidateLibraries(
-    InvalidatedModuleReport invalidatedModuleReport,
-  ) {
-    Set<String> invalidatedLibraries;
-    invalidatedLibraries = invalidatedModuleReport.deletedLibraries.union(
-      invalidatedModuleReport.reloadedLibraries,
-    );
-    final invalidatedModules = invalidatedModuleReport.deletedModules.union(
-      invalidatedModuleReport.reloadedModules,
-    );
-    for (final library in invalidatedLibraries) {
-      final libraryServerPath = _getLibraryServerPath(library);
-      _sourceToLibrary.remove(libraryServerPath);
-      _sourceToModule.remove(libraryServerPath);
-      _libraryToModule.remove(library);
-    }
-    for (final module in invalidatedModules) {
-      _moduleToSources.remove(module);
-    }
-    return invalidatedLibraries;
-  }
-
   /// Initializes [_sourceToModule], [_moduleToSources], and [_sourceToLibrary].
   ///
-  /// If [invalidatedModuleReport] is not null, only updates the maps for the
-  /// invalidated libraries in the report.
+  /// If [modifiedModuleReport] is not null, only updates the maps for the
+  /// modified libraries in the report.
   Future<void> _initializeMapping([
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {
     final provider = globalToolConfiguration.loadStrategy.metadataProviderFor(
       _entrypoint,
@@ -132,16 +122,11 @@ class Modules {
     final libraryToScripts = await provider.scripts;
     final scriptToModule = await provider.scriptToModule;
 
-    final invalidatedLibraries =
-        invalidatedModuleReport != null
-            ? _invalidateLibraries(invalidatedModuleReport)
-            : null;
-
     for (final library in libraryToScripts.keys) {
-      if (invalidatedLibraries != null) {
+      if (modifiedModuleReport != null) {
         // Note that every module will have at least one library associated with
-        // it, so it's okay to only process the invalidated libraries.
-        if (!invalidatedLibraries.contains(library)) continue;
+        // it, so it's okay to only process the modified libraries.
+        if (!modifiedModuleReport.modifiedLibraries.contains(library)) continue;
       }
       final scripts = libraryToScripts[library]!;
       final libraryServerPath = _getLibraryServerPath(library);

dwds/lib/src/debugging/skip_list.dart

@@ -20,21 +20,18 @@ class SkipLists {
 
   Future<void> initialize([
     String? entrypoint,
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {
-    if (invalidatedModuleReport != null) {
+    if (modifiedModuleReport != null) {
       assert(entrypoint != null);
-      final invalidatedModules = invalidatedModuleReport.deletedModules.union(
-        invalidatedModuleReport.reloadedModules,
-      );
       for (final url in _urlToId.keys) {
         if (url.isEmpty) continue;
 
         final dartUri = DartUri(url, _root);
         final serverPath = dartUri.serverPath;
         final module = await globalToolConfiguration.loadStrategy
             .moduleForServerPath(entrypoint!, serverPath);
-        if (invalidatedModules.contains(module)) {
+        if (modifiedModuleReport.modifiedModules.contains(module)) {
           _idToList.remove(_urlToId[url]!);
         }
       }

dwds/lib/src/loaders/strategy.dart

@@ -183,7 +183,7 @@ abstract class LoadStrategy {
     return Future.value();
   }
 
-  Future<InvalidatedModuleReport> reinitializeEntrypointAfterReload(
+  Future<ModifiedModuleReport> reinitializeEntrypointAfterReload(
     String entrypoint,
     Map<String, List> reloadedModulesToLibraries,
   ) {

dwds/lib/src/services/chrome_proxy_service.dart

@@ -235,34 +235,29 @@ class ChromeProxyService implements VmServiceInterface {
   }
 
   /// Reinitializes any caches so that they can be recomputed across hot reload.
-  // TODO(srujzs): We can maybe do better here than reinitializing all the data.
-  // Specifically, we can invalidate certain parts as we know what libraries
-  // will be stale, and therefore recompute information only for those libraries
-  // and possibly libraries that depend on them. Currently, there's no good
-  // separation between "existing" information and "new" information, making
-  // this difficult.
-  // https://github.com/dart-lang/webdev/issues/2628
+  ///
+  /// We use the [ModifiedModuleReport] to more efficiently invalidate caches.
   Future<void> _reinitializeForHotReload(
     Map<String, List> reloadedModules,
   ) async {
     final entrypoint = inspector.appConnection.request.entrypointPath;
-    final invalidatedModuleReport = await globalToolConfiguration.loadStrategy
+    final modifiedModuleReport = await globalToolConfiguration.loadStrategy
         .reinitializeEntrypointAfterReload(entrypoint, reloadedModules);
-    await _initializeEntrypoint(entrypoint, invalidatedModuleReport);
-    await inspector.initialize(invalidatedModuleReport);
+    await _initializeEntrypoint(entrypoint, modifiedModuleReport);
+    await inspector.initialize(modifiedModuleReport);
   }
 
   /// Initializes metadata in [Locations], [Modules], and [ExpressionCompiler].
   ///
-  /// If [invalidatedModuleReport] is not null, only removes and reinitializes
-  /// invalidated metadata.
+  /// If [modifiedModuleReport] is not null, only removes and reinitializes
+  /// modified metadata.
   Future<void> _initializeEntrypoint(
     String entrypoint, [
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {
-    await _modules.initialize(entrypoint, invalidatedModuleReport);
-    await _locations.initialize(entrypoint, invalidatedModuleReport);
-    await _skipLists.initialize(entrypoint, invalidatedModuleReport);
+    await _modules.initialize(entrypoint, modifiedModuleReport);
+    await _locations.initialize(entrypoint, modifiedModuleReport);
+    await _skipLists.initialize(entrypoint, modifiedModuleReport);
     // We do not need to wait for compiler dependencies to be updated as the
     // [ExpressionEvaluator] is robust to evaluation requests during updates.
     safeUnawaited(_updateCompilerDependencies(entrypoint));

dwds/test/fixtures/fakes.dart

@@ -68,9 +68,8 @@ class FakeInspector implements AppInspector {
   }
 
   @override
-  Future<void> initialize([
-    InvalidatedModuleReport? invalidatedModuleReport,
-  ]) async => {};
+  Future<void> initialize([ModifiedModuleReport? modifiedModuleReport]) async =>
+      {};
 
   @override
   Future<InstanceRef?> instanceRefFor(Object value) async =>
@@ -161,7 +160,7 @@ class FakeModules implements Modules {
   @override
   Future<void> initialize(
     String entrypoint, [
-    InvalidatedModuleReport? invalidatedModuleReport,
+    ModifiedModuleReport? modifiedModuleReport,
   ]) async {}
 
   @override