[dart2js] Support running modular analysis alongside building a dill.

Change-Id: If10385445c5f6267e2de20b090b37e1741b7ace7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/237925
Reviewed-by: Johnni Winther <[email protected]>
Reviewed-by: Sigmund Cherem <[email protected]>
Commit-Queue: Joshua Litt <[email protected]>

Author: joshualitt

pkg/compiler/lib/src/commandline_options.dart

@@ -112,6 +112,7 @@ class Flags {
   static const String reportAllMetrics = '--report-all-metrics';
 
   static const String dillDependencies = '--dill-dependencies';
+  static const String sources = '--sources';
   static const String readData = '--read-data';
   static const String writeData = '--write-data';
   static const String noClosedWorldInData = '--no-closed-world-in-data';

pkg/compiler/lib/src/dart2js.dart

@@ -133,6 +133,7 @@ Future<api.CompilationResult> compile(List<String> argv,
   bool showWarnings;
   bool showHints;
   bool enableColors;
+  List<Uri> sources;
   int optimizationLevel = null;
   Uri platformBinaries;
   Map<String, String> environment = Map<String, String>();
@@ -289,11 +290,12 @@ Future<api.CompilationResult> compile(List<String> argv,
         Uri.base.resolve(extractPath(argument, isDirectory: true));
   }
 
-  void setUriList(String flag, String argument) {
+  List<Uri> setUriList(String flag, String argument) {
     String list = extractParameter(argument);
-    String uriList = list.splitMapJoin(',',
-        onMatch: (_) => ',', onNonMatch: (p) => '${fe.nativeToUri(p)}');
+    List<Uri> uris = list.split(',').map(fe.nativeToUri).toList();
+    String uriList = uris.map((uri) => '$uri').join(',');
     options.add('${flag}=${uriList}');
+    return uris;
   }
 
   void setModularAnalysisInputs(String argument) {
@@ -361,6 +363,10 @@ Future<api.CompilationResult> compile(List<String> argv,
     setUriList(Flags.dillDependencies, argument);
   }
 
+  void setSources(String argument) {
+    sources = setUriList(Flags.sources, argument);
+  }
+
   void setCfeOnly(String argument) {
     if (writeStrategy == WriteStrategy.toModularAnalysis) {
       fail("Cannot use ${Flags.cfeOnly} "
@@ -547,6 +553,7 @@ Future<api.CompilationResult> compile(List<String> argv,
     OptionHandler('--library-root=.+', ignoreOption),
     OptionHandler('--libraries-spec=.+', setLibrarySpecificationUri),
     OptionHandler('${Flags.dillDependencies}=.+', setDillDependencies),
+    OptionHandler('${Flags.sources}=.+', setSources),
     OptionHandler('${Flags.readModularAnalysis}=.+', setModularAnalysisInputs),
     OptionHandler(
         '${Flags.writeModularAnalysis}|${Flags.writeModularAnalysis}=.+',
@@ -761,7 +768,10 @@ Future<api.CompilationResult> compile(List<String> argv,
     helpAndExit(wantHelp, wantVersion, diagnosticHandler.verbose);
   }
 
-  if (arguments.isEmpty && entryUri == null && inputDillUri == null) {
+  if (arguments.isEmpty &&
+      entryUri == null &&
+      inputDillUri == null &&
+      sources == null) {
     helpAndFail('No Dart file specified.');
   }
 
@@ -787,8 +797,11 @@ Future<api.CompilationResult> compile(List<String> argv,
   }
 
   // Make [scriptName] a relative path..
-  String scriptName =
-      fe.relativizeUri(Uri.base, inputDillUri ?? entryUri, Platform.isWindows);
+  String scriptName = sources == null
+      ? fe.relativizeUri(Uri.base, inputDillUri ?? entryUri, Platform.isWindows)
+      : sources
+          .map((uri) => fe.relativizeUri(Uri.base, uri, Platform.isWindows))
+          .join(',');
 
   switch (writeStrategy) {
     case WriteStrategy.toJs:

pkg/compiler/lib/src/options.dart

@@ -171,6 +171,7 @@ class CompilerOptions implements DiagnosticOptions {
   Uri? get compilationTarget => inputDillUri ?? entryUri;
 
   bool get fromDill {
+    if (sources != null) return false;
     var targetPath = compilationTarget!.path;
     return targetPath.endsWith('.dill');
   }
@@ -191,6 +192,9 @@ class CompilerOptions implements DiagnosticOptions {
   /// files for linking.
   List<Uri>? dillDependencies;
 
+  /// A list of sources to compile, only used for modular analysis.
+  List<Uri>? sources;
+
   Uri? writeModularAnalysisUri;
 
   /// Helper to determine if compiler is being run just for modular analysis.
@@ -676,6 +680,7 @@ class CompilerOptions implements DiagnosticOptions {
       ..showInternalProgress = _hasOption(options, Flags.progress)
       ..dillDependencies =
           _extractUriListOption(options, '${Flags.dillDependencies}')
+      ..sources = _extractUriListOption(options, '${Flags.sources}')
       ..readProgramSplit =
           _extractUriOption(options, '${Flags.readProgramSplit}=')
       ..writeModularAnalysisUri =

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

@@ -195,8 +195,10 @@ Future<_LoadFromKernelResult> _loadFromKernel(CompilerOptions options,
 class _LoadFromSourceResult {
   final ir.Component component;
   final fe.InitializedCompilerState initializedCompilerState;
+  final List<Uri> moduleLibraries;
 
-  _LoadFromSourceResult(this.component, this.initializedCompilerState);
+  _LoadFromSourceResult(
+      this.component, this.initializedCompilerState, this.moduleLibraries);
 }
 
 Future<_LoadFromSourceResult> _loadFromSource(
@@ -215,21 +217,36 @@ Future<_LoadFromSourceResult> _loadFromSource(
       reportFrontEndMessage(reporter, message);
     }
   };
-  fe.CompilerOptions feOptions = fe.CompilerOptions()
-    ..target = target
-    ..librariesSpecificationUri = options.librariesSpecificationUri
-    ..packagesFileUri = options.packageConfig
-    ..explicitExperimentalFlags = options.explicitExperimentalFlags
-    ..verbose = verbose
-    ..fileSystem = fileSystem
-    ..onDiagnostic = onDiagnostic
-    ..verbosity = verbosity;
-  Uri resolvedUri = options.compilationTarget;
-  bool isLegacy = await fe.uriUsesLegacyLanguageVersion(resolvedUri, feOptions);
-  _inferNullSafetyMode(options, !isLegacy);
 
+  // If we are passed a list of sources, then we are performing a modular
+  // compile. In this case, we cannot infer null safety from the source files
+  // and must instead rely on the options passed in on the command line.
+  bool isModularCompile = false;
+  List<Uri> sources = [];
+  if (options.sources != null) {
+    isModularCompile = true;
+    sources.addAll(options.sources);
+  } else {
+    fe.CompilerOptions feOptions = fe.CompilerOptions()
+      ..target = target
+      ..librariesSpecificationUri = options.librariesSpecificationUri
+      ..packagesFileUri = options.packageConfig
+      ..explicitExperimentalFlags = options.explicitExperimentalFlags
+      ..verbose = verbose
+      ..fileSystem = fileSystem
+      ..onDiagnostic = onDiagnostic
+      ..verbosity = verbosity;
+    Uri resolvedUri = options.compilationTarget;
+    bool isLegacy =
+        await fe.uriUsesLegacyLanguageVersion(resolvedUri, feOptions);
+    _inferNullSafetyMode(options, !isLegacy);
+    sources.add(options.compilationTarget);
+  }
+
+  // If we are performing a modular compile, we expect the platform binary to be
+  // supplied along with other dill dependencies.
   List<Uri> dependencies = [];
-  if (options.platformBinaries != null) {
+  if (options.platformBinaries != null && !isModularCompile) {
     dependencies.add(options.platformBinaries
         .resolve(_getPlatformFilename(options, targetName)));
   }
@@ -248,10 +265,17 @@ Future<_LoadFromSourceResult> _loadFromSource(
           options.useLegacySubtyping ? fe.NnbdMode.Weak : fe.NnbdMode.Strong,
       invocationModes: options.cfeInvocationModes,
       verbosity: verbosity);
-  ir.Component component = await fe.compile(
-      initializedCompilerState, verbose, fileSystem, onDiagnostic, resolvedUri);
+  ir.Component component = await fe.compile(initializedCompilerState, verbose,
+      fileSystem, onDiagnostic, sources, isModularCompile);
   _validateNullSafetyMode(options);
-  return _LoadFromSourceResult(component, initializedCompilerState);
+
+  // We have to compute canonical names on the component here to avoid missing
+  // canonical names downstream.
+  if (isModularCompile) {
+    component.computeCanonicalNames();
+  }
+  return _LoadFromSourceResult(
+      component, initializedCompilerState, isModularCompile ? sources : []);
 }
 
 Output _createOutput(
@@ -336,6 +360,7 @@ Future<Output> run(Input input) async {
         reporter, input.initializedCompilerState, targetName);
     component = result.component;
     initializedCompilerState = result.initializedCompilerState;
+    moduleLibraries = result.moduleLibraries;
   }
   if (component == null) return null;
   if (input.forceSerialization) {

pkg/compiler/test/end_to_end/no_platform_test.dart

@@ -30,7 +30,8 @@ main() {
         (fe.DiagnosticMessage message) {
       message.plainTextFormatted.forEach(print);
       Expect.notEquals(fe.Severity.error, message.severity);
-    }, Uri.base.resolve('pkg/compiler/test/end_to_end/data/hello_world.dart'));
+    }, [Uri.base.resolve('pkg/compiler/test/end_to_end/data/hello_world.dart')],
+        false);
     Expect.isNotNull(new ir.CoreTypes(component).futureClass);
   }
 

pkg/compiler/tool/modular_test_suite.dart

@@ -21,7 +21,8 @@ main(List<String> args) async {
         options,
         IOPipeline([
           OutlineDillCompilationStep(),
-          FullDillCompilationStep(),
+          FullDillCompilationStep(onlyOnSdk: true),
+          ModularAnalysisStep(onlyOnSdk: true),
           ModularAnalysisStep(),
           ConcatenateDillsStep(useModularAnalysis: true),
           ComputeClosedWorldStep(useModularAnalysis: true),