[dart2js] Add a 'modular analysis' phase.

Change-Id: Idda666911a15e1726a15db65eb0cce2733851fdc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/237633
Reviewed-by: Mark Zhou <markzipan@google.com>
Commit-Queue: Joshua Litt <joshualitt@google.com>

Author: joshualitt

pkg/compiler/lib/src/compiler.dart

@@ -50,6 +50,7 @@ import 'kernel/kernel_world.dart';
 import 'null_compiler_output.dart' show NullCompilerOutput;
 import 'options.dart' show CompilerOptions;
 import 'phase/load_kernel.dart' as load_kernel;
+import 'phase/modular_analysis.dart' as modular_analysis;
 import 'serialization/task.dart';
 import 'serialization/serialization.dart';
 import 'serialization/strategies.dart';
@@ -322,7 +323,11 @@ class Compiler {
       programSplitConstraintsData = constraintParser.read(programSplitJson);
     }
 
-    if (onlyPerformGlobalTypeInference) {
+    if (options.cfeOnly) {
+      await runLoadKernel();
+    } else if (options.modularMode) {
+      await runModularAnalysis();
+    } else if (onlyPerformGlobalTypeInference) {
       ir.Component component =
           await serializationTask.deserializeComponentAndUpdateOptions();
       var closedWorldAndIndices =
@@ -357,48 +362,25 @@ class Compiler {
       await generateJavaScriptCode(globalTypeInferenceResults,
           indices: closedWorldAndIndices.indices);
     } else {
-      final input = load_kernel.Input(options, provider, reporter,
-          initializedCompilerState, forceSerializationForTesting);
-      load_kernel.Output output =
-          await loadKernelTask.measure(() async => load_kernel.run(input));
+      load_kernel.Output output = await runLoadKernel();
       if (output == null || compilationFailed) return;
-      reporter.log("Kernel load complete");
-      if (retainDataForTesting) {
-        componentForTesting = output.component;
-      }
 
       ir.Component component = output.component;
       List<Uri> libraries = output.libraries;
       frontendStrategy.registerLoadedLibraries(component, libraries);
-
-      if (options.modularMode) {
-        await runModularAnalysis(component, output.moduleLibraries);
-      } else {
-        List<ModuleData> data;
-        if (options.hasModularAnalysisInputs) {
-          data = await serializationTask.deserializeModuleData(component);
-        }
-        frontendStrategy.registerModuleData(data);
-
-        // After we've deserialized modular data, we trim the component of any
-        // unnecessary dependencies.
-        // Note: It is critical we wait to trim the dill until after we've
-        // deserialized modular data because some of this data may reference
-        // 'trimmed' elements.
-        if (options.fromDill) {
-          if (options.dumpUnusedLibraries) {
-            dumpUnusedLibraries(component, libraries);
-          }
-          if (options.entryUri != null) {
-            component = trimComponent(component, libraries);
-          }
-        }
-        if (options.cfeOnly) {
-          await serializationTask.serializeComponent(component);
-        } else {
-          await compileFromKernel(output.rootLibraryUri, libraries);
-        }
+      List<ModuleData> data;
+      if (options.hasModularAnalysisInputs) {
+        data = await serializationTask.deserializeModuleData(component);
       }
+      frontendStrategy.registerModuleData(data);
+
+      // After we've deserialized modular data, we trim the component of any
+      // unnecessary dependencies.
+      // Note: It is critical we wait to trim the dill until after we've
+      // deserialized modular data because some of this data may reference
+      // 'trimmed' elements.
+      dumpUnusedLibrariesAndTrimComponent(component, libraries);
+      await compileFromKernel(output.rootLibraryUri, libraries);
     }
   }
 
@@ -498,19 +480,54 @@ class Compiler {
     return closedWorld;
   }
 
-  void runModularAnalysis(
-      ir.Component component, Iterable<Uri> moduleLibraries) {
+  Future<load_kernel.Output> runLoadKernel() async {
+    final input = load_kernel.Input(options, provider, reporter,
+        initializedCompilerState, forceSerializationForTesting);
+    load_kernel.Output output =
+        await loadKernelTask.measure(() async => load_kernel.run(input));
+    if (output == null || compilationFailed) return null;
+    reporter.log("Kernel load complete");
+    if (retainDataForTesting) {
+      componentForTesting = output.component;
+    }
+
+    if (options.cfeOnly) {
+      ir.Component component = output.component;
+      dumpUnusedLibrariesAndTrimComponent(component, output.libraries);
+      await serializationTask.serializeComponent(component);
+    }
+    return output;
+  }
+
+  void dumpUnusedLibrariesAndTrimComponent(
+      ir.Component component, List<Uri> libraries) {
+    if (options.fromDill) {
+      if (options.dumpUnusedLibraries) {
+        dumpUnusedLibraries(component, libraries);
+      }
+      if (options.entryUri != null) {
+        component = trimComponent(component, libraries);
+      }
+    }
+  }
+
+  void runModularAnalysis() async {
+    load_kernel.Output output = await runLoadKernel();
+    if (output == null || compilationFailed) return;
+
+    ir.Component component = output.component;
+    List<Uri> libraries = output.libraries;
+    Set<Uri> moduleLibraries = output.moduleLibraries.toSet();
     _userCodeLocations
         .addAll(moduleLibraries.map((module) => CodeLocation(module)));
-    selfTask.measureSubtask('runModularAnalysis', () {
-      var included = moduleLibraries.toSet();
-      var elementMap = frontendStrategy.elementMap;
-      var moduleData = computeModuleData(
-          component, included, options, reporter, environment, elementMap);
-      if (compilationFailed) return;
-      serializationTask.testModuleSerialization(moduleData, component);
-      serializationTask.serializeModuleData(moduleData, component, included);
-    });
+    final input = modular_analysis.Input(
+        options, reporter, environment, component, libraries, moduleLibraries);
+    ModuleData moduleData = await selfTask.measureSubtask(
+        'runModularAnalysis', () async => modular_analysis.run(input));
+    if (compilationFailed) return;
+    serializationTask.testModuleSerialization(moduleData, component);
+    serializationTask.serializeModuleData(
+        moduleData, component, moduleLibraries);
   }
 
   GlobalTypeInferenceResults performGlobalTypeInference(

pkg/compiler/lib/src/ir/modular.dart

@@ -12,8 +12,6 @@ import 'package:front_end/src/api_unstable/dart2js.dart' as ir
 import '../diagnostics/diagnostic_listener.dart';
 import '../diagnostics/messages.dart';
 import '../diagnostics/source_span.dart';
-import '../kernel/element_map.dart';
-import '../environment.dart';
 import '../ir/impact_data.dart';
 import '../ir/static_type.dart';
 import '../js_backend/annotations.dart';
@@ -92,40 +90,6 @@ ModularMemberData computeModularMemberData(ir.Member node,
   return ModularMemberData(scopeModel, impactBuilderData);
 }
 
-ModuleData computeModuleData(
-    ir.Component component,
-    Set<Uri> includedLibraries,
-    CompilerOptions options,
-    DiagnosticReporter reporter,
-    Environment environment,
-    KernelToElementMap elementMap) {
-  var classHierarchy = elementMap.classHierarchy;
-  var typeEnvironment = elementMap.typeEnvironment;
-  var constantEvaluator = elementMap.constantEvaluator;
-  var result = <ir.Member, ImpactBuilderData>{};
-  void computeForMember(ir.Member member) {
-    var scopeModel = ScopeModel.from(member, constantEvaluator);
-    var annotations = processMemberAnnotations(
-        options, reporter, member, computePragmaAnnotationDataFromIr(member));
-    result[member] = computeModularMemberData(member,
-            options: options,
-            typeEnvironment: typeEnvironment,
-            classHierarchy: classHierarchy,
-            scopeModel: scopeModel,
-            annotations: annotations)
-        .impactBuilderData;
-  }
-
-  for (var library in component.libraries) {
-    if (!includedLibraries.contains(library.importUri)) continue;
-    library.members.forEach(computeForMember);
-    for (var cls in library.classes) {
-      cls.members.forEach(computeForMember);
-    }
-  }
-  return ModuleData(result);
-}
-
 void reportLocatedMessage(DiagnosticReporter reporter,
     ir.LocatedMessage message, List<ir.LocatedMessage> context) {
   DiagnosticMessage diagnosticMessage =

pkg/compiler/lib/src/kernel/element_map_impl.dart

@@ -38,7 +38,6 @@ import '../js_backend/annotations.dart';
 import '../js_backend/namer.dart';
 import '../js_backend/native_data.dart';
 import '../js_model/locals.dart';
-import '../kernel/kernel_strategy.dart';
 import '../kernel/dart2js_target.dart';
 import '../native/behavior.dart';
 import '../options.dart';
@@ -58,6 +57,9 @@ class KernelToElementMap implements IrToElementMap {
   @override
   final DiagnosticReporter reporter;
   final Environment _environment;
+  final NativeBasicDataBuilder nativeBasicDataBuilder =
+      NativeBasicDataBuilder();
+  NativeBasicData _nativeBasicData;
   KCommonElements _commonElements;
   KernelElementEnvironment _elementEnvironment;
   DartTypeConverter _typeConverter;
@@ -101,12 +103,10 @@ class KernelToElementMap implements IrToElementMap {
   final Map<ir.TreeNode, Local> localFunctionMap = {};
 
   BehaviorBuilder _nativeBehaviorBuilder;
-  final KernelFrontendStrategy _frontendStrategy;
 
   Map<KMember, Map<ir.Expression, TypeMap>> typeMapsForTesting;
 
-  KernelToElementMap(
-      this.reporter, this._environment, this._frontendStrategy, this.options) {
+  KernelToElementMap(this.reporter, this._environment, this.options) {
     _elementEnvironment = KernelElementEnvironment(this);
     _typeConverter = DartTypeConverter(this);
     _types = KernelDartTypes(this, options);
@@ -1422,7 +1422,16 @@ class KernelToElementMap implements IrToElementMap {
   }
 
   /// NativeBasicData is need for computation of the default super class.
-  NativeBasicData get nativeBasicData => _frontendStrategy.nativeBasicData;
+  NativeBasicData get nativeBasicData {
+    if (_nativeBasicData == null) {
+      _nativeBasicData = nativeBasicDataBuilder.close(elementEnvironment);
+      assert(
+          _nativeBasicData != null,
+          failedAt(NO_LOCATION_SPANNABLE,
+              "NativeBasicData has not been computed yet."));
+    }
+    return _nativeBasicData;
+  }
 
   /// Adds libraries in [component] to the set of libraries.
   ///

pkg/compiler/lib/src/kernel/kernel_strategy.dart

@@ -50,9 +50,6 @@ import 'native_basic_data.dart';
 /// Front end strategy that loads '.dill' files and builds a resolved element
 /// model from kernel IR nodes.
 class KernelFrontendStrategy {
-  final NativeBasicDataBuilder nativeBasicDataBuilder =
-      NativeBasicDataBuilder();
-  NativeBasicData _nativeBasicData;
   final CompilerOptions _options;
   final CompilerTask _compilerTask;
   KernelToElementMap _elementMap;
@@ -84,7 +81,7 @@ class KernelFrontendStrategy {
   KernelFrontendStrategy(this._compilerTask, this._options,
       DiagnosticReporter reporter, env.Environment environment) {
     assert(_compilerTask != null);
-    _elementMap = KernelToElementMap(reporter, environment, this, _options);
+    _elementMap = KernelToElementMap(reporter, environment, _options);
     _modularStrategy = KernelModularStrategy(_compilerTask, _elementMap);
     _backendUsageBuilder = BackendUsageBuilderImpl(this);
     noSuchMethodRegistry =
@@ -135,6 +132,7 @@ class KernelFrontendStrategy {
       CompilerTask task, Compiler compiler) {
     RuntimeTypesNeedBuilder rtiNeedBuilder = _createRuntimeTypesNeedBuilder();
     BackendImpacts impacts = BackendImpacts(commonElements, compiler.options);
+    final nativeBasicData = _elementMap.nativeBasicData;
     _nativeResolutionEnqueuer = NativeResolutionEnqueuer(
         compiler.options,
         elementEnvironment,
@@ -217,24 +215,13 @@ class KernelFrontendStrategy {
         annotationsData);
   }
 
-  NativeBasicData get nativeBasicData {
-    if (_nativeBasicData == null) {
-      _nativeBasicData = nativeBasicDataBuilder.close(elementEnvironment);
-      assert(
-          _nativeBasicData != null,
-          failedAt(NO_LOCATION_SPANNABLE,
-              "NativeBasicData has not been computed yet."));
-    }
-    return _nativeBasicData;
-  }
-
   /// Registers a set of loaded libraries with this strategy.
   void registerLoadedLibraries(ir.Component component, List<Uri> libraries) {
     _elementMap.addComponent(component);
     _irAnnotationData = processAnnotations(
         ModularCore(component, _elementMap.constantEvaluator));
     _annotationProcessor = KernelAnnotationProcessor(
-        elementMap, nativeBasicDataBuilder, _irAnnotationData);
+        elementMap, elementMap.nativeBasicDataBuilder, _irAnnotationData);
     for (Uri uri in libraries) {
       LibraryEntity library = elementEnvironment.lookupLibrary(uri);
       if (maybeEnableNative(library.canonicalUri)) {

pkg/compiler/lib/src/phase/load_kernel.dart

@@ -50,15 +50,15 @@ class Output {
   /// reachable from the [rootLibraryUri].
   ///
   /// Note that [component] may contain some libraries that are excluded here.
-  final Iterable<Uri> libraries;
+  final List<Uri> libraries;
 
   /// When running only dart2js modular analysis, returns the [Uri]s for
   /// libraries loaded in the input module.
   ///
   /// This excludes other libraries reachable from them that were loaded as
   /// dependencies. The result of [moduleLibraries] is always a subset of
   /// [libraries].
-  final Iterable<Uri> moduleLibraries;
+  final List<Uri> moduleLibraries;
 
   final fe.InitializedCompilerState initializedCompilerState;