Invalidate deleted modules and libraries and process reloaded modules and libraries in provider

Author: srujzs

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

@@ -103,8 +103,6 @@ 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

@@ -15,15 +15,14 @@ class MetadataProvider {
   final AssetReader _assetReader;
   final _logger = Logger('MetadataProvider');
   final String entrypoint;
-  final List<String> _libraries = [];
+  final Set<String> _libraries = {};
   final Map<String, String> _scriptToModule = {};
   final Map<String, String> _moduleToSourceMap = {};
   final Map<String, String> _modulePathToModule = {};
   final Map<String, String> _moduleToModulePath = {};
+  final Map<String, Set<String>> _moduleToLibraries = {};
   final Map<String, List<String>> _scripts = {};
   final _metadataMemoizer = AsyncMemoizer();
-  // Whether to use the `name` provided in the module metadata.
-  final bool _useModuleName;
 
   /// Implicitly imported libraries in any DDC component.
   ///
@@ -66,11 +65,7 @@ class MetadataProvider {
     'dart:ui',
   ];
 
-  MetadataProvider(
-    this.entrypoint,
-    this._assetReader, {
-    required bool useModuleName,
-  }) : _useModuleName = useModuleName;
+  MetadataProvider(this.entrypoint, this._assetReader);
 
   /// A sound null safety mode for the whole app.
   ///
@@ -81,17 +76,17 @@ class MetadataProvider {
     return true;
   }
 
-  /// A list of all libraries in the Dart application.
+  /// A set of all libraries in the Dart application.
   ///
   /// Example:
   ///
-  ///  [
+  ///  {
   ///     dart:web_gl,
   ///     dart:math,
   ///     org-dartlang-app:///web/main.dart
-  ///  ]
+  ///  }
   ///
-  Future<List<String>> get libraries async {
+  Future<Set<String>> get libraries async {
     await _initialize();
     return _libraries;
   }
@@ -118,9 +113,6 @@ class MetadataProvider {
   ///   org-dartlang-app:///web/main.dart :
   ///   web/main
   /// }
-  ///
-  /// If [_useModuleName] is false, the values will be the module paths instead
-  /// of the name except for 'dart_sdk'.
   Future<Map<String, String>> get scriptToModule async {
     await _initialize();
     return _scriptToModule;
@@ -134,9 +126,6 @@ class MetadataProvider {
   ///   org-dartlang-app:///web/main.dart :
   ///   web/main.ddc.js.map
   /// }
-  ///
-  /// If [_useModuleName] is false, the keys will be the module paths instead of
-  /// the name.
   Future<Map<String, String>> get moduleToSourceMap async {
     await _initialize();
     return _moduleToSourceMap;
@@ -150,9 +139,6 @@ class MetadataProvider {
   ///   web/main.ddc.js :
   ///   web/main
   /// }
-  ///
-  /// If [_useModuleName] is false, the values will be the module paths instead
-  /// of the name, making this an identity map.
   Future<Map<String, String>> get modulePathToModule async {
     await _initialize();
     return _modulePathToModule;
@@ -166,9 +152,6 @@ class MetadataProvider {
   ///   web/main
   ///   web/main.ddc.js :
   /// }
-  ///
-  /// If [_useModuleName] is false, the keys will be the module paths instead of
-  /// the name, making this an identity map.
   Future<Map<String, String>> get moduleToModulePath async {
     await _initialize();
     return _moduleToModulePath;
@@ -182,67 +165,108 @@ class MetadataProvider {
   ///   web/main,
   ///   web/foo/bar
   /// ]
-  ///
-  /// If [_useModuleName] is false, this will be the set of module paths
-  /// instead.
   Future<List<String>> get modules async {
     await _initialize();
     return _moduleToModulePath.keys.toList();
   }
 
-  Future<void> _initialize() async {
-    await _metadataMemoizer.runOnce(() async {
-      // The merged metadata resides next to the entrypoint.
-      // Assume that <name>.bootstrap.js has <name>.ddc_merged_metadata
-      if (entrypoint.endsWith('.bootstrap.js')) {
-        _logger.info('Loading debug metadata...');
-        final serverPath = entrypoint.replaceAll(
-          '.bootstrap.js',
-          '.ddc_merged_metadata',
-        );
-        final merged = await _assetReader.metadataContents(serverPath);
-        if (merged != null) {
-          _addSdkMetadata();
-          for (final contents in merged.split('\n')) {
-            try {
-              if (contents.isEmpty ||
-                  contents.startsWith('// intentionally empty:')) {
-                continue;
-              }
-              final moduleJson = json.decode(contents);
-              final metadata = ModuleMetadata.fromJson(
-                moduleJson as Map<String, dynamic>,
-              );
+  Future<Map<String, ModuleMetadata>?> _processMetadata(bool hotReload) async {
+    final modules = hotReload ? <String, ModuleMetadata>{} : null;
+    // The merged metadata resides next to the entrypoint.
+    // Assume that <name>.bootstrap.js has <name>.ddc_merged_metadata
+    if (entrypoint.endsWith('.bootstrap.js')) {
+      _logger.info('Loading debug metadata...');
+      final serverPath = entrypoint.replaceAll(
+        '.bootstrap.js',
+        '.ddc_merged_metadata',
+      );
+      final merged = await _assetReader.metadataContents(serverPath);
+      if (merged != null) {
+        // We can't hot reload the SDK yet, so no need to invalidate this data.
+        if (!hotReload) _addSdkMetadata();
+        for (final contents in merged.split('\n')) {
+          try {
+            if (contents.isEmpty ||
+                contents.startsWith('// intentionally empty:')) {
+              continue;
+            }
+            final moduleJson = json.decode(contents);
+            final metadata = ModuleMetadata.fromJson(
+              moduleJson as Map<String, dynamic>,
+            );
+            final moduleName = metadata.name;
+            if (hotReload) {
+              modules?[moduleName] = metadata;
+            } else {
               _addMetadata(metadata);
-              final moduleName =
-                  _useModuleName ? metadata.name : metadata.moduleUri;
-              _logger.fine('Loaded debug metadata for module: $moduleName');
-            } catch (e) {
-              _logger.warning('Failed to read metadata: $e');
-              rethrow;
             }
+            _logger.fine('Loaded debug metadata for module: $moduleName');
+          } catch (e) {
+            _logger.warning('Failed to read metadata: $e');
+            rethrow;
           }
         }
       }
-    });
+    }
+    return modules;
+  }
+
+  Future<void> _initialize() async {
+    await _metadataMemoizer.runOnce(() => _processMetadata(false));
+  }
+
+  Future<void> reinitializeAfterReload(Set<String> reloadedModules) async {
+    final modules = (await _processMetadata(true))!;
+    final invalidatedLibraries = <String>{};
+    void invalidateLibrary(String libraryImportUri) {
+      invalidatedLibraries.add(libraryImportUri);
+      _libraries.remove(libraryImportUri);
+      _scriptToModule.remove(libraryImportUri);
+      _scripts[libraryImportUri]?.forEach(_scriptToModule.remove);
+      _scripts.remove(libraryImportUri);
+    }
+
+    final deletedModules = <String>{};
+    final invalidatedModules = <String>{};
+    for (final module in _moduleToLibraries.keys) {
+      final deletedModule = !modules.containsKey(module);
+      final invalidatedModule = reloadedModules.contains(module);
+      assert(!(deletedModule && invalidatedModule));
+      // If the module was either deleted or reloaded, invalidate all previous
+      // information both about the module and its libraries.
+      if (deletedModule || invalidatedModule) {
+        _modulePathToModule.remove(module);
+        _moduleToLibraries[module]?.forEach(invalidateLibrary);
+        _moduleToModulePath.remove(module);
+        _moduleToSourceMap.remove(module);
+      }
+      if (deletedModule) deletedModules.add(module);
+    }
+    for (final module in reloadedModules) {
+      _addMetadata(modules[module]!);
+    }
+    // The libraries that were removed from the program or those that we
+    // invalidated but were never added again.
+    final deletedLibraries = invalidatedLibraries.where(
+      (library) => !_libraries.contains(library),
+    );
   }
 
   void _addMetadata(ModuleMetadata metadata) {
     final modulePath = stripLeadingSlashes(metadata.moduleUri);
     final sourceMapPath = stripLeadingSlashes(metadata.sourceMapUri);
-    // DDC library bundle module format does not provide names for library
-    // bundles, and therefore we use the URI instead to represent a library
-    // bundle.
-    final moduleName = _useModuleName ? metadata.name : modulePath;
+    final moduleName = metadata.name;
 
     _moduleToSourceMap[moduleName] = sourceMapPath;
     _modulePathToModule[modulePath] = moduleName;
     _moduleToModulePath[moduleName] = modulePath;
 
+    final moduleLibraries = <String>{};
     for (final library in metadata.libraries.values) {
       if (library.importUri.startsWith('file:/')) {
         throw AbsoluteImportUriException(library.importUri);
       }
+      moduleLibraries.add(library.importUri);
       _libraries.add(library.importUri);
       _scripts[library.importUri] = [];
 
@@ -254,6 +278,7 @@ class MetadataProvider {
         _scriptToModule[partPath] = moduleName;
       }
     }
+    _moduleToLibraries[moduleName] = moduleLibraries;
   }
 
   void _addSdkMetadata() {
@@ -264,7 +289,8 @@ class MetadataProvider {
       _scripts[lib] = [];
       // TODO(srujzs): It feels weird that we add this mapping to only this map
       // and not any of the other module maps. We should maybe handle this
-      // differently.
+      // differently. This will become relevant if we ever support hot reload
+      // for the Dart SDK.
       _scriptToModule[lib] = moduleName;
     }
   }