[frontend_server] Refactor usage of module to library bundle

With the new (and eventually, only) module format, we refer
to collections of libraries as bundles rather than modules.
This convention is a better fit as the frontend server
already treats modules as a collection of libraries.

Furthermore, places where we use the word "module" may be
better communicated by using "library bundle import" (the
component URI) or "library bundle name" (the synthesized
name we give library bundles).

This CL leaves usages of modules that are tied to user-facing
flags for clarity, e.g. "module format" and "useDebuggerModuleNames".
It also ignores usages where the intention is very much tied
to a module e.g. when using require.js.

Change-Id: I363b1eac955f710accece9fa3a8ea2624c751430
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/397200
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Nicholas Shahan <[email protected]>
Commit-Queue: Srujan Gaddam <[email protected]>

Author: srujzs

pkg/front_end/test/spell_checking_list_code.txt

@@ -1707,6 +1707,7 @@ sq
 sra
 srawlins
 src
+srujzs
 ssa
 st
 stability

pkg/frontend_server/lib/frontend_server.dart

@@ -1569,6 +1569,7 @@ StreamSubscription<String> listenAndCompile(CompilerInterface compiler,
         state = _State.COMPILE_EXPRESSION_TO_JS_JSMODULES;
         break;
       case _State.COMPILE_EXPRESSION_TO_JS_JSMODULES:
+        // TODO(srujzs): Deprecate jsModules as we never use this.
         if (string == boundaryKey) {
           state = _State.COMPILE_EXPRESSION_TO_JS_JSFRAMEVALUES;
         } else {

pkg/frontend_server/lib/src/javascript_bundle.dart

@@ -23,8 +23,10 @@ import 'strong_components.dart';
 /// Produce a special bundle format for compiled JavaScript.
 ///
 /// The bundle format consists of two files: One containing all produced
-/// JavaScript modules concatenated together, and a second containing the byte
-/// offsets by module name for each JavaScript module in JSON format.
+/// JavaScript library bundles concatenated together, and a second containing
+/// the byte offsets by the synthesized library bundle name for each JavaScript
+/// library bundle in JSON format. The library bundle name is based off of a
+/// library URI from the associated component.
 ///
 /// The format is analogous to the dill and .incremental.dill in that during
 /// an incremental build, a different file is written for each which contains
@@ -49,10 +51,9 @@ class IncrementalJavaScriptBundler {
   final FileSystem? _fileSystem;
   final Set<Library> _loadedLibraries;
   final Map<Uri, Component> _uriToComponent = <Uri, Component>{};
-  final _importToSummary = new Map<Library, Component>.identity();
-  final _summaryToModule = new Map<Component, String>.identity();
-  final Map<Uri, String> _moduleImportForSummary = <Uri, String>{};
-  final Map<Uri, String> _moduleImportNameForSummary = <Uri, String>{};
+  final _libraryToSummary = new Map<Library, Component>.identity();
+  final _summaryToLibraryBundleName = new Map<Component, String>.identity();
+  final Map<Uri, String> _summaryToLibraryBundleJSPath = <Uri, String>{};
   final String _fileSystemScheme;
 
   late Component _lastFullComponent;
@@ -70,8 +71,9 @@ class IncrementalJavaScriptBundler {
       mainUri,
       _fileSystem,
     );
-    await _strongComponents.computeModules();
-    _updateSummaries(_strongComponents.modules.keys, packageConfig);
+    await _strongComponents.computeLibraryBundles();
+    _updateSummaries(
+        _strongComponents.libraryBundleImportToLibraries.keys, packageConfig);
   }
 
   /// Update the incremental bundler from a partial component and the last full
@@ -90,13 +92,14 @@ class IncrementalJavaScriptBundler {
       _fileSystem,
     );
 
-    await _strongComponents.computeModules(<Uri, Library>{
+    await _strongComponents.computeLibraryBundles(<Uri, Library>{
       for (Library library in partialComponent.libraries)
         library.importUri: library,
     });
     Set<Uri> invalidated = <Uri>{
       for (Library library in partialComponent.libraries)
-        _strongComponents.moduleAssignment[library.importUri]!,
+        _strongComponents
+            .libraryImportToLibraryBundleImport[library.importUri]!,
     };
     _updateSummaries(invalidated, packageConfig);
   }
@@ -123,10 +126,12 @@ class IncrementalJavaScriptBundler {
     }
   }
 
-  /// Update the summaries [moduleKeys].
-  void _updateSummaries(Iterable<Uri> moduleKeys, PackageConfig packageConfig) {
-    for (Uri uri in moduleKeys) {
-      final List<Library> libraries = _strongComponents.modules[uri]!.toList();
+  /// Update the summaries using the [libraryBundleImports].
+  void _updateSummaries(
+      Iterable<Uri> libraryBundleImports, PackageConfig packageConfig) {
+    for (Uri uri in libraryBundleImports) {
+      final List<Library> libraries =
+          _strongComponents.libraryBundleImportToLibraries[uri]!.toList();
       final Component summaryComponent = new Component(
         libraries: libraries,
         nameRoot: _lastFullComponent.root,
@@ -136,34 +141,33 @@ class IncrementalJavaScriptBundler {
           null, false, _currentComponent.mode);
 
       String baseName = urlForComponentUri(uri, packageConfig);
-      _moduleImportForSummary[uri] = '$baseName.lib.js';
-      _moduleImportNameForSummary[uri] = makeModuleName(baseName);
+      _summaryToLibraryBundleJSPath[uri] = '$baseName.lib.js';
+      // Library bundle loaders loads bundles by bundle names, not paths
+      String libraryBundleName = makeLibraryBundleName(baseName);
 
       _uriToComponent[uri] = summaryComponent;
-      // module loaders loads modules by modules names, not paths
-      String moduleImport = _moduleImportNameForSummary[uri]!;
 
       List<Component> oldSummaries = [];
-      for (Component summary in _summaryToModule.keys) {
-        if (_summaryToModule[summary] == moduleImport) {
+      for (Component summary in _summaryToLibraryBundleName.keys) {
+        if (_summaryToLibraryBundleName[summary] == libraryBundleName) {
           oldSummaries.add(summary);
         }
       }
       for (Component summary in oldSummaries) {
-        _summaryToModule.remove(summary);
+        _summaryToLibraryBundleName.remove(summary);
       }
-      _importToSummary
+      _libraryToSummary
           .removeWhere((key, value) => oldSummaries.contains(value));
 
       for (Library library in summaryComponent.libraries) {
-        assert(!_importToSummary.containsKey(library));
-        _importToSummary[library] = summaryComponent;
-        _summaryToModule[summaryComponent] = moduleImport;
+        assert(!_libraryToSummary.containsKey(library));
+        _libraryToSummary[library] = summaryComponent;
+        _summaryToLibraryBundleName[summaryComponent] = libraryBundleName;
       }
     }
   }
 
-  /// Compile each component into a single JavaScript module.
+  /// Compile each component into a single JavaScript library bundle.
   Future<Map<String, Compiler>> compile(
     ClassHierarchy classHierarchy,
     CoreTypes coreTypes,
@@ -187,25 +191,27 @@ class IncrementalJavaScriptBundler {
           library.importUri.isScheme('dart')) {
         continue;
       }
-      final Uri moduleUri =
-          _strongComponents.moduleAssignment[library.importUri]!;
-      if (visited.containsKey(moduleUri)) {
-        kernel2JsCompilers[library.importUri.toString()] = visited[moduleUri]!;
+      final Uri libraryBundleImport = _strongComponents
+          .libraryImportToLibraryBundleImport[library.importUri]!;
+      if (visited.containsKey(libraryBundleImport)) {
+        kernel2JsCompilers[library.importUri.toString()] =
+            visited[libraryBundleImport]!;
         continue;
       }
 
-      final Component summaryComponent = _uriToComponent[moduleUri]!;
+      final Component summaryComponent = _uriToComponent[libraryBundleImport]!;
 
-      // module name to use in trackLibraries
-      // use full path for tracking if module uri is not a package uri.
-      final String moduleUrl = urlForComponentUri(moduleUri, packageConfig);
-      final String moduleName = makeModuleName(moduleUrl);
+      final String componentUrl =
+          urlForComponentUri(libraryBundleImport, packageConfig);
+      // library bundle name to use in trackLibraries
+      // use full path for tracking if library bundle uri is not a package uri.
+      final String libraryBundleName = makeLibraryBundleName(componentUrl);
       final Options ddcOptions = new Options(
         sourceMap: true,
         summarizeApi: false,
         emitDebugMetadata: emitDebugMetadata,
         emitDebugSymbols: emitDebugSymbols,
-        moduleName: moduleName,
+        moduleName: libraryBundleName,
         soundNullSafety: true,
         canaryFeatures: canaryFeatures,
         moduleFormats: [_moduleFormat],
@@ -215,44 +221,45 @@ class IncrementalJavaScriptBundler {
               _currentComponent,
               classHierarchy,
               ddcOptions,
-              _importToSummary,
-              _summaryToModule,
+              _libraryToSummary,
+              _summaryToLibraryBundleName,
               coreTypes: coreTypes,
             )
           : new ProgramCompiler(
               _currentComponent,
               classHierarchy,
               ddcOptions,
-              _importToSummary,
-              _summaryToModule,
+              _libraryToSummary,
+              _summaryToLibraryBundleName,
               coreTypes: coreTypes,
             );
 
-      final Program jsModule = compiler.emitModule(summaryComponent);
+      final Program jsBundle = compiler.emitModule(summaryComponent);
 
       // Save program compiler to reuse for expression evaluation.
       kernel2JsCompilers[library.importUri.toString()] = compiler;
-      visited[moduleUri] = compiler;
+      visited[libraryBundleImport] = compiler;
 
       String? sourceMapBase;
-      if (moduleUri.isScheme('package')) {
+      if (libraryBundleImport.isScheme('package')) {
         // Source locations come through as absolute file uris. In order to
         // make relative paths in the source map we get the absolute uri for
-        // the module and make them relative to that.
-        sourceMapBase = p.dirname((packageConfig.resolve(moduleUri))!.path);
+        // the library bundle and make them relative to that.
+        sourceMapBase =
+            p.dirname((packageConfig.resolve(libraryBundleImport))!.path);
       }
 
       final JSCode code = jsProgramToCode(
-        jsModule,
+        jsBundle,
         ddcOptions.emitLibraryBundle
             ? ModuleFormat.ddcLibraryBundle
             : _moduleFormat,
         inlineSourceMap: true,
         buildSourceMap: true,
         emitDebugMetadata: emitDebugMetadata,
         emitDebugSymbols: emitDebugSymbols,
-        jsUrl: '$moduleUrl.lib.js',
-        mapUrl: '$moduleUrl.lib.js.map',
+        jsUrl: '$componentUrl.lib.js',
+        mapUrl: '$componentUrl.lib.js.map',
         sourceMapBase: sourceMapBase,
         customScheme: _fileSystemScheme,
         compiler: compiler,
@@ -273,8 +280,9 @@ class IncrementalJavaScriptBundler {
       if (emitDebugSymbols) {
         symbolsSink!.add(symbolsBytes!);
       }
-      final String moduleKey = _moduleImportForSummary[moduleUri]!;
-      manifest[moduleKey] = {
+      final String libraryBundleJSPath =
+          _summaryToLibraryBundleJSPath[libraryBundleImport]!;
+      manifest[libraryBundleJSPath] = {
         'code': <int>[codeOffset, codeOffset += codeBytes.length],
         'sourcemap': <int>[
           sourceMapOffset,
@@ -297,22 +305,20 @@ class IncrementalJavaScriptBundler {
     return kernel2JsCompilers;
   }
 
-  /// Module name used in the browser to load modules.
+  /// Library bundle name used in the browser to load library bundles.
   ///
-  /// Module names are used to load modules using module
-  /// paths maps in RequireJS, which treats names with
-  /// leading '/' or '.js' extensions specially, and tries
-  /// to load them without mapping.
-  /// Skip the leading '/' to always load modules via module
-  /// path maps.
-  String makeModuleName(String name) {
+  /// Library bundle names are used to load library bundles using library bundle
+  /// path maps in RequireJS, which treats names with leading '/' or '.js'
+  /// extensions specially, and tries to load them without mapping. Skip the
+  /// leading '/' to always load library bundles via library bundle path maps.
+  String makeLibraryBundleName(String name) {
     return name.startsWith('/') ? name.substring(1) : name;
   }
 
   /// Create component url.
   ///
-  /// Used as a server path in the browser for the module created
-  /// from the component.
+  /// Used as a server path in the browser for the library bundle created from
+  /// the component.
   String urlForComponentUri(Uri componentUri, PackageConfig packageConfig) {
     if (!componentUri.isScheme('package')) {
       return componentUri.path;

pkg/frontend_server/lib/src/strong_components.dart

@@ -13,14 +13,15 @@ import 'package:kernel/util/graph.dart';
 /// Implements a Path-based strong component algorithm.
 /// See https://en.wikipedia.org/wiki/Path-based_strong_component_algorithm
 ///
-/// The file URI for each library is used as an identifier for the module
-/// name. [moduleAssignment] will be populated with a mapping of library URI to
-/// module name, while [modules] will be populated with a mapping of module
-/// name to library set.
+/// The file URI for each library is used as an identifier for the library
+/// bundle name. [libraryImportToLibraryBundleImport] will be populated with a
+/// mapping of library URI to library bundle name, while
+/// [libraryBundleImportToLibraries] will be populated with a mapping of library
+/// bundle name to library set.
 ///
 /// JavaScript import semantics do not permit circular imports in the same
 /// manner that Dart does. When compiling a set of libraries with circular
-/// imports, these must be combined into a single JavaScript module.
+/// imports, these must be combined into a single JavaScript library bundle.
 ///
 /// On incremental updates, we completely recompute the strongly connected
 /// components, but only for the partial component produced.
@@ -47,15 +48,16 @@ class StrongComponents {
   /// The filesystem instance for resolving files.
   final FileSystem? fileSystem;
 
-  /// The set of libraries for each module URI.
+  /// Libraries for each library bundle URI.
   ///
-  /// This is populated after calling [computeModules] once.
-  final Map<Uri, List<Library>> modules = <Uri, List<Library>>{};
+  /// This is populated after calling [computeLibraryBundles] once.
+  final Map<Uri, List<Library>> libraryBundleImportToLibraries =
+      <Uri, List<Library>>{};
 
-  /// The module URI for each library file URI.
+  /// The library bundle URI for each library URI.
   ///
-  /// This is populated after calling [computeModules] once.
-  final Map<Uri, Uri> moduleAssignment = <Uri, Uri>{};
+  /// This is populated after calling [computeLibraryBundles] once.
+  final Map<Uri, Uri> libraryImportToLibraryBundleImport = <Uri, Uri>{};
 
   /// Compute the strongly connected components for the current program.
   ///
@@ -66,8 +68,9 @@ class StrongComponents {
   ///
   /// Throws an [Exception] if [mainUri] cannot be located in the given
   /// component.
-  Future<void> computeModules([Map<Uri, Library>? partialComponent]) async {
-    assert(modules.isEmpty);
+  Future<void> computeLibraryBundles(
+      [Map<Uri, Library>? partialComponent]) async {
+    assert(libraryBundleImportToLibraries.isEmpty);
     if (component.libraries.isEmpty) {
       return;
     }
@@ -87,13 +90,16 @@ class StrongComponents {
         new _LibraryGraph(entrypoint, loadedLibraries, partialComponent));
     for (List<Library> component in results) {
       assert(component.isNotEmpty);
-      final Uri moduleUri = component
+      // Pick a Uri to associate this component with. We choose the entrypoint
+      // if it exists or just the first library's Uri.
+      final Uri componentUri = component
           .firstWhere((lib) => lib.importUri == mainUri,
               orElse: () => component.first)
           .importUri;
-      modules[moduleUri] = component;
+      libraryBundleImportToLibraries[componentUri] = component;
       for (Library componentLibrary in component) {
-        moduleAssignment[componentLibrary.importUri] = moduleUri;
+        libraryImportToLibraryBundleImport[componentLibrary.importUri] =
+            componentUri;
       }
     }
   }