First step for modular output in fasta.

pkg/front_end/lib/kernel_generator.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// Defines the front-end API for converting source code to Dart Kernel objects.
 library front_end.kernel_generator;
 
 import 'compiler_options.dart';
 import 'dart:async' show Future;
 import 'dart:async';
-import 'package:front_end/physical_file_system.dart';
+import 'package:front_end/src/base/processed_options.dart';
 import 'src/fasta/dill/dill_target.dart' show DillTarget;
 import 'src/fasta/errors.dart' show InputError;
 import 'src/fasta/kernel/kernel_target.dart' show KernelTarget;
 import 'package:kernel/kernel.dart' show Program;
 import 'src/fasta/ticker.dart' show Ticker;
 import 'src/fasta/translate_uri.dart' show TranslateUri;
 import 'src/simple_error.dart';
 
 /// Generates a kernel representation of the program whose main library is in
 /// the given [source].
 ///
 /// Intended for whole program (non-modular) compilation.
 ///
 /// Given the Uri of a file containing a program's `main` method, this function
 /// follows `import`, `export`, and `part` declarations to discover the whole
 /// program, and converts the result to Dart Kernel format.
 ///
 /// If `compileSdk` in [options] is true, the generated program will include
 /// code for the SDK.
 ///
-/// If summaries are provided in [options], they may be used to speed up
-/// analysis. If in addition `compileSdk` is false, this will speed up
-/// compilation, as no source of the sdk will be generated.  Note however, that
-/// summaries for application code can also speed up analysis, but they will not
-/// take the place of Dart source code (since the Dart source code is still
-/// needed to access the contents of method bodies).
+/// If summaries are provided in [options], they will be used to speed up
+/// the process. If in addition `compileSdk` is false, then the resulting
+/// program will not contain the sdk contents. This is useful when building apps
+/// for platforms that already embed the sdk (e.g. the VM), so there is no need
+/// to spend time and space rebuilding it.
 Future<Program> kernelForProgram(Uri source, CompilerOptions options) async {
   var fs = options.fileSystem;
-
   report(String msg) {
     options.onError(new SimpleError(msg));
     return null;
   }
 
   if (!await fs.entityForUri(source).exists()) {
     return report("Entry-point file not found: $source");
   }
 
-  if (!await validateOptions(options)) return null;
+  var pOptions = new ProcessedOptions(options);

[Siggi Cherem (dart-lang), 2017/05/18 04:51:13]

Using processedOptions for a variable felt just very long :) - other ideas?

+
+  if (!await pOptions.validateOptions()) return null;
 
   try {
-    TranslateUri uriTranslator = await TranslateUri.parse(
-        PhysicalFileSystem.instance, null, options.packagesFileUri);
+    TranslateUri uriTranslator = await pOptions.getUriTranslator();
 
     var dillTarget =
         new DillTarget(new Ticker(isVerbose: false), uriTranslator);
-    var summary = options.sdkSummary;
-    if (summary != null) dillTarget.read(summary);
+    var summary = await pOptions.sdkSummaryProgram;
+    if (summary != null) {
+      dillTarget.loader.appendLibraries(summary);
+    }
 
     var kernelTarget = new KernelTarget(
         options.fileSystem, dillTarget, uriTranslator, options.strongMode);
     kernelTarget.read(source);
 
     await dillTarget.buildOutlines();
     await kernelTarget.buildOutlines();
-    Program program = await kernelTarget.buildProgram();
+    Program program = await kernelTarget.buildProgram(trimDependencies: true);
 
     if (kernelTarget.errors.isNotEmpty) {
       kernelTarget.errors.forEach(report);
       return null;
     }
 
     if (program.mainMethod == null) {
       return report("No 'main' method found.");
     }
 
@@ skipping 36 matching lines @@
 ///
 /// The return value is a [Program] object with no main method set.
 /// TODO(paulberry): would it be better to define a data type in kernel to
 /// represent a bundle of all the libraries in a given build unit?
 ///
 /// TODO(paulberry): does additional information need to be output to allow the
 /// caller to match up referenced elements to the summary files they were
 /// obtained from?
 Future<Program> kernelForBuildUnit(
     List<Uri> sources, CompilerOptions options) async {
-  throw new UnimplementedError("kernel for build-unit is not implemented");
+  var fs = options.fileSystem;
+  report(String msg) {
+    options.onError(new SimpleError(msg));
+    return null;
+  }
+
+  if (!options.chaseDependencies) {
+    // TODO(sigmund): add support, most likely we can do so by adding a wrapper
+    // on top of filesystem that restricts reads to a set of known files.
+    report("hermetic mode (chaseDependencies = false) is not implemented");
+    return null;
+  }
+
+  for (var source in sources) {
+    if (!await fs.entityForUri(source).exists()) {
+      return report("Entry-point file not found: $source");
+    }
+  }
+
+  var pOptions = new ProcessedOptions(options);
+
+  if (!await pOptions.validateOptions()) return null;
+
+  try {
+    TranslateUri uriTranslator = await pOptions.getUriTranslator();
+
+    var dillTarget =
+        new DillTarget(new Ticker(isVerbose: false), uriTranslator);
+    var summary = await pOptions.sdkSummaryProgram;
+    if (summary != null) {
+      dillTarget.loader.appendLibraries(summary);
+    }
+
+    // TODO(sigmund): this is likely not going to work if done naively: if
+    // summaries contain external references we need to ensure they are loaded
+    // in a specific order.

[Siggi Cherem (dart-lang), 2017/05/18 04:51:13]

Konstantin - I want to sync up with you on this a bit. It is highly related to
what you had to do for the incremental generator, so I'd like to pick your brain
on it

[scheglov, 2017/05/18 15:54:08]

There might be a chicken and egg problem here - in order to use dill files to
determine the right order we would need to load them to use import/export
directives (when and if they have import/export information). IKG get around
this by using Dart files directly to compute the graph first. We could have
additional files with graph information or make dill files lazily loaded so that
we could load only unresolved imports/exports first.

+    for (var inputSummary in await pOptions.inputSummariesPrograms) {
+      dillTarget.loader.appendLibraries(inputSummary);
+    }
+
+    await dillTarget.buildOutlines();
+
+    var kernelTarget = new KernelTarget(
+        options.fileSystem, dillTarget, uriTranslator, options.strongMode);
+    sources.forEach(kernelTarget.read);
+    await kernelTarget.buildOutlines();
+
+    Program program = await kernelTarget.buildProgram(trimDependencies: true);
+
+    if (kernelTarget.errors.isNotEmpty) {
+      kernelTarget.errors.forEach(report);
+      return null;
+    }
+
+    return program;
+  } on InputError catch (e) {
+    options.onError(new SimpleError(e.format()));
+    return null;
+  }
 }