Unifying compiler context

pkg/front_end/lib/src/fasta/compiler_command_line.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.
 
 library fasta.compiler_command_line;
 
 import 'dart:io' show exit;
 
-import 'dart:async' show runZoned;
-
 import 'package:kernel/target/targets.dart'
     show Target, getTarget, TargetFlags, targets;
 
+import 'package:front_end/compiler_options.dart';
+import 'package:front_end/src/base/processed_options.dart';

[ahe, 2017/07/18 16:54:37]

Use relative URIs.

[Siggi Cherem (dart-lang), 2017/07/18 22:50:43]

Done.

BTW, the reason I used package:* here is that my general style preference is to
use relative for going deeper and non-relative for going up (../../* is a bit
harder to follow for me).

Happy to keep the existing style, but let me know if you like my general rule
for future code.

 import 'command_line.dart' show CommandLine, deprecated_argumentError;
 
-import 'compiler_context.dart' show CompilerContext, compilerContextKey;
-
-import 'command_line_reporting.dart' as command_line_reporting;
+import 'compiler_context.dart' show CompilerContext;
 
 import 'fasta_codes.dart'
     show
-        LocatedMessage,
         Message,
         messageFastaUsageLong,
         messageFastaUsageShort,
         templateUnspecified;
 
-import 'severity.dart' show Severity;
-
 const Map<String, dynamic> optionSpecification = const <String, dynamic>{
   "--compile-sdk": Uri,
   "--fatal": ",",
   "--output": Uri,
   "-o": Uri,
   "--packages": Uri,
   "--platform": Uri,
   "--sdk": Uri,
   "--target": String,
   "-t": String,
 };
 
+/// Parser for options accepted by the `fasta` command-line tools.
+// TODO(ahe,sigmund): move this and other tools under pkg/front_end/tool/
 class CompilerCommandLine extends CommandLine {
   final String programName;
 
   CompilerCommandLine(String programName, List<String> arguments)
       : programName = programName,
         super(arguments,
             specification: optionSpecification,
             usage: computeUsage(programName, false));
 
   bool get verify => options.containsKey("--verify");
 
   bool get dumpIr => options.containsKey("--dump-ir");
 
   bool get excludeSource => options.containsKey("--exclude-source");
 
   bool get help {
     return options.containsKey("--help") ||
         options.containsKey("-h") ||
         options.containsKey("/h") ||
         options.containsKey("/?");
   }
 
-  bool get setExitCodeOnProblem {
-    return options.containsKey("--set-exit-code-on-problem");
-  }
-
   void validate() {
     if (help) {
-      print(computeUsage(programName, verbose));
+      print(computeUsage(programName, verbose).message);
       exit(0);
     }
 
     if (options.containsKey("-o") && options.containsKey("--output")) {
       return deprecated_argumentError(
           usage, "Can't specify both '-o' and '--output'.");
     }
     if (options.containsKey("-t") && options.containsKey("--target")) {
       return deprecated_argumentError(
           usage, "Can't specify both '-t' and '--target'.");
     }
     if (options.containsKey("--compile-sdk") &&
         options.containsKey("--platform")) {
       return deprecated_argumentError(
           usage, "Can't specify both '--compile-sdk' and '--platform'.");
     }
-    if (programName == "compile_platform" && arguments.length != 3) {
-      return deprecated_argumentError(usage, "Expected three arguments.");
+    if (programName == "compile_platform") {
+      if (arguments.length != 3) {
+        return deprecated_argumentError(usage, "Expected three arguments.");
+      }
+      if (options.containsKey("--compile-sdk")) {
+        return deprecated_argumentError(
+            usage, "Ignored '--compile-sdk' option.");

[ahe, 2017/07/18 16:54:37]

This option isn't really ignored as it's reporting an error here.

[Siggi Cherem (dart-lang), 2017/07/18 22:50:43]

Good point, rephrased

+      }
+      options['--compile-sdk'] =
+          Uri.base.resolveUri(new Uri.file(arguments[0]));
     } else if (arguments.isEmpty) {
       return deprecated_argumentError(usage, "No Dart file specified.");
     }
 
     Target target =
         getTarget(targetName, new TargetFlags(strongMode: strongMode));
     if (target == null) {
       return deprecated_argumentError(
           usage,
           "Target '${targetName}' not recognized. "
           "Valid targets are:\n  ${targets.keys.join("\n  ")}");
     }
     options["target"] = target;
   }
 
   Uri get output {
     return options["-o"] ?? options["--output"] ?? defaultOutput;
   }
 
   Uri get defaultOutput => Uri.base.resolve("${arguments.first}.dill");
 
   Uri get platform {
     return options.containsKey("--compile-sdk")
         ? null
         : options["--platform"] ?? Uri.base.resolve("platform.dill");
   }
 
-  Uri get packages => options["--packages"] ?? Uri.base.resolve(".packages");
+  Uri get packages => options["--packages"];
 
   Uri get sdk => options["--sdk"] ?? options["--compile-sdk"];
 
   Set<String> get fatal {
     return new Set<String>.from(options["--fatal"] ?? <String>[]);
   }
 
   bool get errorsAreFatal => fatal.contains("errors");
 
   bool get warningsAreFatal => fatal.contains("warnings");
 
   bool get nitsAreFatal => fatal.contains("nits");
 
   bool get strongMode => options.containsKey("--strong-mode");
 
   String get targetName {
     return options["-t"] ?? options["--target"] ?? "vm_fasta";
   }
 
   Target get target => options["target"];
 
-  void Function(LocatedMessage, Severity) get report {
-    return options["report"] ?? command_line_reporting.report;
-  }
+  static dynamic withGlobalOptions(
+      String programName,
+      List<String> arguments,
+      bool areRestArgumentsInputs,
+      dynamic f(CompilerContext context, List<String> restArguments)) {

[ahe, 2017/07/18 10:40:50]

This method needs to create a Ticker as the first thing it does. Ideally, it
should be passed a Ticker.

[ahe, 2017/07/18 16:54:37]

We discussed this at our 1:1, handle as you see fit.

[Siggi Cherem (dart-lang), 2017/07/18 22:50:43]

Thanks. The ticker is created in line 172 below eagerly, but I understand what
you mean that this could be too late.

I added a todo next to the creation of the ticker in ProcessedOptions to follow
up on this.

+    // TODO(sigmund,ahe): delete this wrapper by moving validation into the
+    // callback. Note that this requires some subtle changes because validate
+    // sets some implicit options (like --compile-sdk in compile_platform).
+    var cl = CompilerContext.runWithDefaultOptions(
+        (_) => new CompilerCommandLine(programName, arguments));
+    var options = new CompilerOptions()
+      ..compileSdk = cl.options.containsKey("--compile-sdk")
+      ..sdkRoot = cl.sdk
+      ..sdkSummary = cl.platform
+      ..packagesFileUri = cl.packages
+      ..strongMode = cl.strongMode
+      ..target = cl.target
+      ..errorsAreFatal = cl.errorsAreFatal
+      ..warningsAreFatal = cl.warningsAreFatal
+      ..nitsAreFatal = cl.nitsAreFatal
+      ..excludeSourceInformation = cl.excludeSource
+      // All command-line tools take only a single entry point and chase
+      // dependencies, and provide a non-zero exit code when errors are found.
+      ..chaseDependencies = true
+      ..setExitCodeOnProblem = true
+      ..debugDump = cl.dumpIr
+      ..verbose = cl.verbose
+      ..verify = cl.verify;
 
-  void Function(Message, Severity) get reportWithoutLocation {
-    return options["reportWithoutLocation"] ??
-        command_line_reporting.reportWithoutLocation;
-  }
-
-  String Function(LocatedMessage, Severity) get format {
-    return options["format"] ?? command_line_reporting.format;
-  }
-
-  String Function(Message, Severity) get formatWithoutLocation {
-    return options["formatWithoutLocation"] ??
-        command_line_reporting.formatWithoutLocation;
-  }
-
-  static dynamic withGlobalOptions(String programName, List<String> arguments,
-      dynamic f(CompilerContext context)) {
-    CompilerCommandLine cl = deprecated_withDefaultOptions(
-        () => new CompilerCommandLine(programName, arguments));
-    return CompilerContext.withGlobalOptions(cl, f);
-  }
-
-  // TODO(sigmund, ahe): delete. We use this to wrap places where we require a
-  // context but we shoudln't. Right now this includes:
-  //   - constructor calls to CompilerCommandLine (because it is calling
-  //   [validate] which may report errors). This should be fixed by doing
-  //   validation after creating these objects.
-  //   - top-level try-catch in command-line tools that capture
-  //   deprecated_InputError, and then report errors using fasta's error
-  //   reporting mechanism. Those should be unnecessary once we get rid of all
-  //   deprecated_InputErrors.
-  static dynamic deprecated_withDefaultOptions(dynamic f()) {
-    var defaultContext = new CompilerContext(new CompilerCommandLine("", [""]));
-    return runZoned(f, zoneValues: {compilerContextKey: defaultContext});
+    var inputs = <Uri>[];
+    if (areRestArgumentsInputs) {
+      inputs = cl.arguments.map(Uri.base.resolve).toList();
+    }
+    var pOptions = new ProcessedOptions(options, false, inputs, cl.output);
+    return CompilerContext.runWithOptions(pOptions, (c) => f(c, cl.arguments));
   }
 }
 
 Message computeUsage(String programName, bool verbose) {
   String basicUsage = "Usage: $programName [options] dartfile\n";
   String summary;
   String options =
       (verbose ? messageFastaUsageLong.message : messageFastaUsageShort.message)
           .trim();
   switch (programName) {
@@ skipping 18 matching lines @@
   StringBuffer sb = new StringBuffer(basicUsage);
   if (summary != null) {
     sb.writeln();
     sb.writeln(summary);
     sb.writeln();
   }
   sb.write(options);
   // TODO(ahe): Don't use [templateUnspecified].
   return templateUnspecified.withArguments("$sb");
 }