[ddc] Add initial hot reload metadata

* Demonstrates the ability to generate metadata when inspecting the
  last accepted and delta components.
* Attach the metadata to the component right before compiling with DDC.
* Use the metadata to avoid deoptimizations in the initial compile
  when they are only required to support a hot reload.
  * Deletion of all type rules for classes that extend Object in the
    initial compile. In the future this should be reduced further to
    only the classes that had a hierarchy change in a hot reload.
  * Type checks on the return value of getters used to represent
    fields.

Change-Id: I2812b564bc3f4d72f005d4bd11fa55ec0eb394ad
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/404940
Commit-Queue: Nicholas Shahan <[email protected]>
Reviewed-by: Jens Johansen <[email protected]>
Reviewed-by: Nate Biggs <[email protected]>

Author: nshahan

pkg/dev_compiler/lib/src/kernel/compiler_new.dart

@@ -36,6 +36,7 @@ import '../js_ast/source_map_printer.dart'
 import 'compiler.dart' as old;
 import 'constants.dart';
 import 'future_or_normalizer.dart';
+import 'hot_reload_delta_inspector.dart';
 import 'js_interop.dart';
 import 'js_typerep.dart';
 import 'kernel_helpers.dart';
@@ -128,6 +129,12 @@ class LibraryBundleCompiler implements old.Compiler {
   js_ast.Program emitModule(Component component) {
     assert(_options.emitLibraryBundle);
     _ticker?.logMs('Emitting library bundle');
+    // When there is hot reload metadata, update the mappings to the nodes in
+    // the current LibraryIndex before passing it on the library compilers.
+    var repo = component.metadata[hotReloadLibraryMetadataTag]
+        as HotReloadLibraryMetadataRepository?;
+    repo?.mapToIndexedNodes(LibraryIndex.all(component));
+    var metadata = repo?.mapping;
     var compiledLibraries = <js_ast.Program>[];
     for (var library in component.libraries) {
       var libraryCompiler = LibraryCompiler(
@@ -139,6 +146,7 @@ class LibraryBundleCompiler implements old.Compiler {
         coreTypes: _coreTypes,
         ticker: _ticker,
         symbolData: _symbolData,
+        compileForHotReload: metadata?[library],
       );
       _libraryCompilers[library] = libraryCompiler;
       compiledLibraries.add(libraryCompiler.emitLibrary(library));
@@ -599,6 +607,9 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
   /// Supports verbose logging with a timer.
   Ticker? _ticker;
 
+  /// Whether the library is being compiled for a hot reload.
+  bool _compileForHotReload;
+
   factory LibraryCompiler(
     Component component,
     ClassHierarchy hierarchy,
@@ -608,6 +619,7 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     CoreTypes? coreTypes,
     Ticker? ticker,
     required SymbolData symbolData,
+    bool? compileForHotReload,
   }) {
     coreTypes ??= CoreTypes(component);
     var types = TypeEnvironment(coreTypes, hierarchy);
@@ -630,6 +642,7 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       importToSummary,
       summaryToModule,
       symbolData,
+      compileForHotReload ?? false,
     );
   }
 
@@ -647,7 +660,8 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
       this._options,
       this._importToSummary,
       this._summaryToModule,
-      this._symbolData)
+      this._symbolData,
+      this._compileForHotReload)
       : _jsArrayClass = sdk.getClass('dart:_interceptors', 'JSArray'),
         _privateSymbolClass = sdk.getClass('dart:_js_helper', 'PrivateSymbol'),
         _linkedHashMapImplClass = sdk.getClass('dart:_js_helper', 'LinkedMap'),
@@ -871,7 +885,7 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
           typeRulesExceptLegacyJavaScriptObject,
           rulesFunction: 'addRules'));
     }
-    if (typesThatOnlyExtendObject.isNotEmpty) {
+    if (_compileForHotReload && typesThatOnlyExtendObject.isNotEmpty) {
       _typeRuleLinks.add(emitRulesStatement(typesThatOnlyExtendObject.toList(),
           rulesFunction: 'deleteRules'));
     }
@@ -2857,10 +2871,10 @@ class LibraryCompiler extends ComputeOnceConstantVisitor<js_ast.Expression>
     // We avoid emitting casts for top level fields in the legacy SDK since
     // some are used for legacy type checks and must be initialized to avoid
     // infinite loops.
-    var initialFieldValueExpression =
-        !_options.soundNullSafety && _isSdkInternalRuntime(_currentLibrary!)
-            ? valueCache
-            : _emitCast(valueCache, field.type);
+    var initialFieldValueExpression = !_compileForHotReload ||
+            !_options.soundNullSafety && _isSdkInternalRuntime(_currentLibrary!)
+        ? valueCache
+        : _emitCast(valueCache, field.type);
 
     // Lazy static fields require an additional type check around their value
     // cache if their type is updated after hot reload. To avoid a type check

pkg/dev_compiler/lib/src/kernel/hot_reload_delta_inspector.dart

@@ -20,16 +20,21 @@ class HotReloadDeltaInspector {
 
   /// Returns all hot reload rejection errors discovered while comparing [delta]
   /// against the [lastAccepted] version.
-  // TODO(nshahan): Annotate delta component with information for DDC.
+  ///
+  /// Attaches metadata to the [delta] component to be consumed by DDC when
+  /// compiling.
   List<String> compareGenerations(Component lastAccepted, Component delta) {
+    final hotReloadLibraryMetadata =
+        lastAccepted.metadata[hotReloadLibraryMetadataTag]
+                as HotReloadLibraryMetadataRepository? ??
+            HotReloadLibraryMetadataRepository();
     _partialLastAcceptedLibraryIndex = LibraryIndex(lastAccepted,
         [for (var library in delta.libraries) '${library.importUri}']);
     _rejectionMessages.clear();
-
-    for (var library in delta.libraries) {
-      for (var deltaClass in library.classes) {
+    for (var deltaLibrary in delta.libraries) {
+      for (var deltaClass in deltaLibrary.classes) {
         final acceptedClass = _partialLastAcceptedLibraryIndex.tryGetClass(
-            '${library.importUri}', deltaClass.name);
+            '${deltaLibrary.importUri}', deltaClass.name);
         if (acceptedClass == null) {
           // No previous version of the class to compare with.
           continue;
@@ -39,7 +44,14 @@ class HotReloadDeltaInspector {
           _checkConstClassDeletedFields(acceptedClass, deltaClass);
         }
       }
+      hotReloadLibraryMetadata.mapping[deltaLibrary] = true;
     }
+    // Finalize the metadata written in this comparison.
+    hotReloadLibraryMetadata.encodeMapping();
+    // Attaching the metadata to the delta node simplifies the stateless server
+    // approach used by dartpad. Ideally in the future the frontend server can
+    // rely on this being attached to the delta component as well.
+    delta.addMetadataRepository(hotReloadLibraryMetadata);
     return _rejectionMessages;
   }
 
@@ -82,3 +94,79 @@ class HotReloadDeltaInspector {
     }
   }
 }
+
+const hotReloadLibraryMetadataTag = 'ddc.hot-reload-library.metadata';
+
+/// Metadata repository implementation that tracks hot reload information
+/// associated to [Library] nodes.
+///
+/// Currently only tracks if the library should be compiled with the intention
+/// to be hot reloaded.
+// TODO(nshahan): Expand to track more useful information.
+class HotReloadLibraryMetadataRepository extends MetadataRepository<bool> {
+  @override
+  String get tag => hotReloadLibraryMetadataTag;
+
+  /// [mapping] in this repository should not be considered consistently live.
+  ///
+  /// Each hot reload compile request should move through these steps:
+  ///
+  /// * Write: Add entries using `mapping[lib] = data` but they should be
+  ///   considered pending.
+  /// * Finalize Write: After collecting all the entries, [encodeMapping] will
+  ///   persist the pending entries to storage that is consistent across future
+  ///   compiles.
+  /// * Prepare Read: Before reading any values from [mapping] the metadata must
+  ///   be linked to nodes by calling [mapToIndexedNodes].
+  /// * Read: After mapping to nodes in a [LibraryIndex] access metadata using
+  ///  `var data = mapping[lib]` but know that this only contains data that was
+  ///   available to be linked in the previous step.
+  @override
+  Map<Library, bool> mapping = <Library, bool>{};
+
+  @override
+  void writeToBinary(bool metadata, Node node, BinarySink sink) {
+    // TODO(nshahan): How to write all metadata even when there are no
+    // associated nodes.
+  }
+
+  @override
+  bool readFromBinary(Node node, BinarySource source) {
+    // TODO(nshahan): Read metadata when it is available.
+    return false;
+  }
+
+  final _reloadedLibraries = <String, bool>{};
+
+  /// Modifies [mapping] to contain metadata associated with the [Node]s present
+  /// in [index].
+  ///
+  /// This method should always be called before reading values from [mapping].
+  ///
+  /// Clears [mapping] before adding the [Node] to metadata mappings.
+  void mapToIndexedNodes(LibraryIndex index) {
+    mapping.clear();
+    for (var identifier in _reloadedLibraries.keys) {
+      final library = index.tryGetLibrary(identifier);
+      if (library == null) continue;
+      final metadata = _reloadedLibraries[identifier];
+      if (metadata == null) continue;
+
+      mapping[library] = metadata;
+    }
+  }
+
+  /// Encodes the current [mapping] to enable lookup in a future compile
+  /// generation when the `Node` keys are no longer valid.
+  ///
+  /// This method should always be called after writing values to [mapping].
+  ///
+  /// Clears [mapping] after encoding.
+  void encodeMapping() {
+    _reloadedLibraries.addAll({
+      for (var library in mapping.keys)
+        '${library.importUri}': mapping[library]!
+    });
+    mapping.clear();
+  }
+}

pkg/front_end/test/spell_checking_list_common.txt

@@ -1402,6 +1402,7 @@ grouping
 groups
 grow
 growable
+growing
 guaranteed
 guaranteeing
 guarantees

pkg/frontend_server/lib/src/javascript_bundle.dart

@@ -57,6 +57,8 @@ class IncrementalJavaScriptBundler {
   final Map<Uri, String> _summaryToLibraryBundleJSPath = <Uri, String>{};
   final String _fileSystemScheme;
   final HotReloadDeltaInspector _deltaInspector = new HotReloadDeltaInspector();
+  final HotReloadLibraryMetadataRepository _libraryMetadataRepository =
+      new HotReloadLibraryMetadataRepository();
 
   late Component _lastFullComponent;
   late Component _currentComponent;
@@ -86,6 +88,9 @@ class IncrementalJavaScriptBundler {
     if (canaryFeatures &&
         _moduleFormat == ModuleFormat.ddc &&
         !recompileRestart) {
+      // Attach the global metadata to the last full component. The delta
+      // inspector will add to it while comparing the two components.
+      lastFullComponent.addMetadataRepository(_libraryMetadataRepository);
       // Find any potential hot reload rejections before updating the strongly
       // connected component graph.
       final List<String> errors = _deltaInspector.compareGenerations(
@@ -228,24 +233,29 @@ class IncrementalJavaScriptBundler {
         canaryFeatures: canaryFeatures,
         moduleFormats: [_moduleFormat],
       );
-      Compiler compiler = ddcOptions.emitLibraryBundle
-          ? new LibraryBundleCompiler(
-              _currentComponent,
-              classHierarchy,
-              ddcOptions,
-              _libraryToSummary,
-              _summaryToLibraryBundleName,
-              coreTypes: coreTypes,
-            )
-          : new ProgramCompiler(
-              _currentComponent,
-              classHierarchy,
-              ddcOptions,
-              _libraryToSummary,
-              _summaryToLibraryBundleName,
-              coreTypes: coreTypes,
-            );
-
+      Compiler compiler;
+      if (ddcOptions.emitLibraryBundle) {
+        compiler = new LibraryBundleCompiler(
+          _currentComponent,
+          classHierarchy,
+          ddcOptions,
+          _libraryToSummary,
+          _summaryToLibraryBundleName,
+          coreTypes: coreTypes,
+        );
+        // Attach all the hot reload metadata collected so far to the component
+        // that is about to be compiled.
+        summaryComponent.addMetadataRepository(_libraryMetadataRepository);
+      } else {
+        compiler = new ProgramCompiler(
+          _currentComponent,
+          classHierarchy,
+          ddcOptions,
+          _libraryToSummary,
+          _summaryToLibraryBundleName,
+          coreTypes: coreTypes,
+        );
+      }
       final Program jsBundle = compiler.emitModule(summaryComponent);
 
       // Save program compiler to reuse for expression evaluation.