Unifying compiler context

pkg/front_end/lib/src/base/processed_options.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 
-import 'package:front_end/compilation_error.dart';
+import 'package:front_end/compilation_message.dart';
 import 'package:front_end/compiler_options.dart';
 import 'package:front_end/file_system.dart';
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/fasta/fasta_codes.dart';
+import 'package:front_end/src/fasta/problems.dart' show unimplemented;
+import 'package:front_end/src/fasta/severity.dart';
 import 'package:front_end/src/fasta/ticker.dart';
 import 'package:front_end/src/fasta/uri_translator.dart';
 import 'package:front_end/src/fasta/uri_translator_impl.dart';
-import 'package:front_end/src/fasta/problems.dart' show unimplemented;
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/multi_root_file_system.dart';
 import 'package:kernel/kernel.dart'
     show Program, loadProgramFromBytes, CanonicalName;
 import 'package:kernel/target/targets.dart';
 import 'package:kernel/target/vm_fasta.dart';
 import 'package:package_config/packages.dart' show Packages;
 import 'package:package_config/src/packages_impl.dart'
     show NonFilePackagesDirectoryPackages, MapPackages;
 import 'package:package_config/packages_file.dart' as package_config;
 import 'package:source_span/source_span.dart' show SourceSpan, SourceLocation;
+import 'package:front_end/src/fasta/command_line_reporting.dart'
+    as command_line_reporting;
 
 /// All options needed for the front end implementation.
 ///
 /// This includes: all of [CompilerOptions] in a form useful to the
 /// implementation, default values for options that were not provided,
 /// and information derived from how the compiler was invoked (like the
 /// entry-points given to the compiler and whether a modular or whole-program
 /// API was used).
 ///
 /// The intent is that the front end should immediately wrap any incoming
@@ skipping 44 matching lines @@
   Ticker ticker;
 
   bool get verbose => _raw.verbose;
 
   bool get verify => _raw.verify;
 
   bool get debugDump => _raw.debugDump;
 
   bool get setExitCodeOnProblem => _raw.setExitCodeOnProblem;
 
+  bool get embedSourceText => _raw.embedSourceText;
+
+  bool get throwOnErrors => _raw.throwOnErrors;
+
+  bool get throwOnWarnings => _raw.throwOnWarnings;
+
+  bool get throwOnNits => _raw.throwOnNits;
+
   /// Like [CompilerOptions.chaseDependencies] but with the appropriate default
   /// value filled in.
   bool get chaseDependencies => _raw.chaseDependencies ?? !_modularApi;
 
   /// Whether the compiler was invoked with a modular API.
   ///
   /// Used to determine the default behavior for [chaseDependencies].
   final bool _modularApi;
 
   /// The entry-points provided to the compiler.
   final List<Uri> inputs;
 
+  /// The Uri where output is generated, may be null.
+  final Uri output;
+
   /// Initializes a [ProcessedOptions] object wrapping the given [rawOptions].
   ProcessedOptions(CompilerOptions rawOptions,
-      [this._modularApi = false, this.inputs = const []])
+      [this._modularApi = false, this.inputs = const [], this.output])
       : this._raw = rawOptions,
+        // TODO(sigmund, ahe): create ticker even earlier or pass in a stopwatch
+        // collecting time since the start of the VM.
         ticker = new Ticker(isVerbose: rawOptions.verbose);
 
   /// The logger to report compilation progress.
   PerformanceLog get logger {
     return _raw.logger;
   }
 
   /// The byte storage to get and put serialized data.
   ByteStore get byteStore {
     return _raw.byteStore;
   }
 
-  void reportMessage(LocatedMessage message) {
-    _raw.onError(new _CompilationMessage(message));
+  bool get _reportMessages => _raw.reportMessages ?? (_raw.onError == null);
+
+  void report(LocatedMessage message, Severity severity) {
+    if (_raw.onError != null) {
+      _raw.onError(new _CompilationMessage(message, severity));
+    }
+
+    if (_reportMessages) command_line_reporting.report(message, severity);
   }
 
-  void reportMessageWithoutLocation(Message message) =>
-      reportMessage(message.withLocation(null, -1));
+  void reportWithoutLocation(Message message, Severity severity) {
+    if (_raw.onError != null) {
+      _raw.onError(
+          new _CompilationMessage(message.withLocation(null, -1), severity));
+    }
+
+    if (_reportMessages) {
+      command_line_reporting.reportWithoutLocation(message, severity);
+    }
+  }
 
   /// Runs various validations checks on the input options. For instance,
   /// if an option is a path to a file, it checks that the file exists.
   Future<bool> validateOptions() async {
+    if (verbose) print(debugString());
+
     if (inputs.isEmpty) {
-      reportMessageWithoutLocation(messageMissingInput);
+      reportWithoutLocation(messageMissingInput, Severity.error);
       return false;
     }
 
     for (var source in inputs) {
       // Note: we don't translate Uris at this point because some of the
       // validation further below must be done before we even construct an
       // UriTranslator
       // TODO(sigmund): consider validating dart/packages uri right after we
       // build the uri translator.
       if (source.scheme != 'dart' &&
           source.scheme != 'packages' &&
           !await fileSystem.entityForUri(source).exists()) {
-        reportMessageWithoutLocation(
-            templateInputFileNotFound.withArguments('$source'));
+        reportWithoutLocation(
+            templateInputFileNotFound.withArguments('$source'), Severity.error);
         return false;
       }
     }
 
     if (_raw.sdkRoot != null &&
         !await fileSystem.entityForUri(sdkRoot).exists()) {
-      reportMessageWithoutLocation(
-          templateSdkRootNotFound.withArguments('$sdkRoot'));
+      reportWithoutLocation(
+          templateSdkRootNotFound.withArguments('$sdkRoot'), Severity.error);
       return false;
     }
 
     var summary = sdkSummary;
     if (summary != null && !await fileSystem.entityForUri(summary).exists()) {
-      reportMessageWithoutLocation(
-          templateSdkSummaryNotFound.withArguments('$summary'));
+      reportWithoutLocation(
+          templateSdkSummaryNotFound.withArguments('$summary'), Severity.error);
       return false;
     }
 
     if (compileSdk && summary != null) {
-      reportMessageWithoutLocation(
+      reportWithoutLocation(
           templateInternalProblemUnsupported.withArguments(
-              "The compileSdk and sdkSummary options are mutually exclusive"));
+              "The compileSdk and sdkSummary options are mutually exclusive"),
+          Severity.internalProblem);
       return false;
     }
     return true;
   }
 
   /// Determine whether to generate code for the SDK when compiling a
   /// whole-program.
   bool get compileSdk => _raw.compileSdk;
 
   FileSystem _fileSystem;
@@ skipping 79 matching lines @@
   Future<Map<String, Uri>> _parseDartLibraries() async {
     Uri librariesJson = _raw.sdkRoot?.resolve("lib/libraries.json");
     return await computeDartLibraries(fileSystem, librariesJson);
   }
 
   /// Get the package map which maps package names to URIs.
   ///
   /// This is an asynchronous getter since file system operations may be
   /// required to locate/read the packages file.
   Future<Packages> _getPackages() async {
-    if (_packages == null) {
-      if (_raw.packagesFileUri == null) {
-        if (inputs.length > 1) {
-          // TODO(sigmund): consider not reporting an error if we would infer
-          // the same .packages file from all of the inputs.
-          reportMessageWithoutLocation(messageCantInferPackagesFromManyInputs);
-          _packages = Packages.noPackages;
-        } else {
-          _packages = await _findPackages(inputs.first);
-        }
-      } else {
-        _packages = await createPackagesFromFile(_raw.packagesFileUri);
-      }
+    if (_packages != null) return _packages;
+    if (_raw.packagesFileUri != null) {
+      return _packages = await createPackagesFromFile(_raw.packagesFileUri);
     }
-    return _packages;
+
+    if (inputs.length > 1) {
+      // TODO(sigmund): consider not reporting an error if we would infer
+      // the same .packages file from all of the inputs.
+      reportWithoutLocation(
+          messageCantInferPackagesFromManyInputs, Severity.error);
+      return _packages = Packages.noPackages;
+    }
+
+    var input = inputs.first;
+
+    // When compiling the SDK the input files are normaly `dart:` URIs.
+    if (input.scheme == 'dart') return _packages = Packages.noPackages;
+
+    if (input.scheme == 'packages') {
+      report(messageCantInferPackagesFromPackageUri.withLocation(input, -1),
+          Severity.error);
+      return _packages = Packages.noPackages;
+    }
+
+    return _packages = await _findPackages(inputs.first);
   }
 
   /// Create a [Packages] given the Uri to a `.packages` file.
   Future<Packages> createPackagesFromFile(Uri file) async {
     try {
       List<int> contents = await fileSystem.entityForUri(file).readAsBytes();
       Map<String, Uri> map = package_config.parse(contents, file);
       return new MapPackages(map);
     } catch (e) {
-      reportMessage(templateCannotReadPackagesFile
-          .withArguments("$e")
-          .withLocation(file, -1));
+      report(
+          templateCannotReadPackagesFile
+              .withArguments("$e")
+              .withLocation(file, -1),
+          Severity.error);
       return Packages.noPackages;
     }
   }
 
   /// Finds a package resolution strategy using a [FileSystem].
   ///
   /// The [scriptUri] points to a Dart script with a valid scheme accepted by
   /// the [FileSystem].
   ///
   /// This function first tries to locate a `.packages` file in the `scriptUri`
   /// directory. If that is not found, it instead checks for the presence of a
   /// `packages/` directory in the same place.  If that also fails, it starts
   /// checking parent directories for a `.packages` file, and stops if it finds
   /// it.  Otherwise it gives up and returns [Packages.noPackages].
   ///
   /// Note: this is a fork from `package:package_config/discovery.dart` to adapt
   /// it to use [FileSystem]. The logic here is a mix of the logic in the
   /// `findPackagesFromFile` and `findPackagesFromNonFile`:
   ///
   ///    * Like `findPackagesFromFile` resolution searches for parent
   ///    directories
   ///
   ///    * Like `findPackagesFromNonFile` if we resolve packages as the
   ///    `packages/` directory, we can't provide a list of packages that are
   ///    visible.
   Future<Packages> _findPackages(Uri scriptUri) async {
     var dir = scriptUri.resolve('.');
     if (!dir.isAbsolute) {
-      reportMessageWithoutLocation(templateInternalProblemUnsupported
-          .withArguments("Expected input Uri to be absolute: $scriptUri."));
+      reportWithoutLocation(
+          templateInternalProblemUnsupported
+              .withArguments("Expected input Uri to be absolute: $scriptUri."),
+          Severity.internalProblem);
       return Packages.noPackages;
     }
 
     Future<Uri> checkInDir(Uri dir) async {
       Uri candidate = dir.resolve('.packages');
       if (await fileSystem.entityForUri(candidate).exists()) return candidate;
       return null;
     }
 
     // Check for $cwd/.packages
@@ skipping 73 matching lines @@
         allInputs.add(sdkRoot.resolve("lib/libraries.json"));
       }
 
       /// Note: Searching the file-system for the package-config is not
       /// supported in hermetic builds.
       if (_raw.packagesFileUri != null) allInputs.add(_raw.packagesFileUri);
       result = new HermeticFileSystem(allInputs, result);
     }
     return result;
   }
+
+  String debugString() {
+    var sb = new StringBuffer();
+    writeList(String name, List elements) {
+      if (elements.isEmpty) {
+        sb.writeln('$name: <empty>');
+        return;
+      }
+      sb.writeln('$name:');
+      elements.forEach((s) {
+        sb.writeln('  - $s');
+      });
+    }
+
+    sb.writeln('Inputs: ${inputs}');
+    sb.writeln('Output: ${output}');
+
+    sb.writeln('Was error handler provided: '
+        '${_raw.onError == null ? "no" : "yes"}');
+
+    sb.writeln('FileSystem: ${_fileSystem.runtimeType} '
+        '(provided: ${_raw.fileSystem.runtimeType})');
+
+    writeList('Input Summaries', _raw.inputSummaries);
+    writeList('Linked Dependencies', _raw.linkedDependencies);
+    writeList('Multiroots', _raw.multiRoots);
+
+    sb.writeln('Modular: ${_modularApi}');
+    sb.writeln('Hermetic: ${!chaseDependencies}'
+        ' (provided: ${!_raw.chaseDependencies})');
+    sb.writeln('Packages uri: ${_raw.packagesFileUri}');
+    sb.writeln('Packages: ${_packages}');
+
+    sb.writeln('Compile SDK: ${compileSdk}');
+    sb.writeln('SDK root: ${_sdkRoot} (provided: ${_raw.sdkRoot})');
+    sb.writeln('SDK summary: ${_sdkSummary} (provided: ${_raw.sdkSummary})');
+
+    sb.writeln('Strong: ${strongMode}');
+    sb.writeln('Target: ${_target?.name} (provided: ${_raw.target?.name})');
+
+    sb.writeln('throwOnErrorsAreFatal: ${throwOnErrors}');
+    sb.writeln('throwOnWarningsAreFatal: ${throwOnWarnings}');
+    sb.writeln('throwOnNits: ${throwOnNits}');
+    sb.writeln('exit on problem: ${setExitCodeOnProblem}');
+    sb.writeln('Embed sources: ${embedSourceText}');
+    sb.writeln('debugDump: ${debugDump}');
+    sb.writeln('verbose: ${verbose}');
+    sb.writeln('verify: ${verify}');
+    return '$sb';
+  }
 }
 
 /// A [FileSystem] that only allows access to files that have been explicitly
 /// whitelisted.
 class HermeticFileSystem implements FileSystem {
   final Set<Uri> includedFiles;
   final FileSystem _realFileSystem;
 
   HermeticFileSystem(this.includedFiles, this._realFileSystem);
 
   FileSystemEntity entityForUri(Uri uri) {
     if (includedFiles.contains(uri)) return _realFileSystem.entityForUri(uri);
     throw new HermeticAccessException(uri);
   }
 }
 
 class HermeticAccessException extends FileSystemException {
   HermeticAccessException(Uri uri)
       : super(
             uri,
             'Invalid access to $uri: '
             'the file is accessed in a modular hermetic build, '
             'but it was not explicitly listed as an input.');
 
   @override
   String toString() => message;
 }
 
-/// Wraps a [LocatedMessage] to implement the public [CompilationError] API.
-class _CompilationMessage implements CompilationError {
-  final LocatedMessage original;
+/// Wraps a [LocatedMessage] to implement the public [CompilationMessage] API.
+class _CompilationMessage implements CompilationMessage {
+  final LocatedMessage _original;
+  final Severity severity;
 
-  String get message => original.message;
+  String get message => _original.message;
 
-  String get tip => original.tip;
+  String get tip => _original.tip;
+
+  String get analyzerCode => _original.code.analyzerCode;
+
+  String get dart2jsCode => _original.code.dart2jsCode;
 
   SourceSpan get span =>
-      new SourceLocation(original.charOffset, sourceUrl: original.uri)
+      new SourceLocation(_original.charOffset, sourceUrl: _original.uri)
           .pointSpan();
 
-  _CompilationMessage(this.original);
+  _CompilationMessage(this._original, this.severity);
 
   String toString() => message;
 }