Reapply "Tweak public APIs and use them in patch_sdk, dart2js, and kernel-service.""

pkg/front_end/tool/fasta_perf.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.
 
 /// An entrypoint used to run portions of fasta and measure its performance.
 library front_end.tool.fasta_perf;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:analyzer/src/fasta/ast_builder.dart';
+import 'package:front_end/front_end.dart';
 import 'package:front_end/physical_file_system.dart';
-import 'package:front_end/src/fasta/dill/dill_target.dart' show DillTarget;
-import 'package:front_end/src/fasta/kernel/kernel_target.dart'
-    show KernelTarget;
 import 'package:front_end/src/fasta/parser.dart';
 import 'package:front_end/src/fasta/scanner.dart';
 import 'package:front_end/src/fasta/scanner/io.dart' show readBytesFromFileSync;
 import 'package:front_end/src/fasta/source/directive_listener.dart';
-import 'package:front_end/src/fasta/ticker.dart' show Ticker;
 import 'package:front_end/src/fasta/translate_uri.dart' show TranslateUri;
-import 'package:front_end/src/fasta/translate_uri.dart';
-import 'package:front_end/src/fasta/parser/dart_vm_native.dart'
+import 'package:front_end/src/fasta/parser/native_support.dart'
     show skipNativeClause;
-import 'package:kernel/target/targets.dart' show TargetFlags;
-import 'package:kernel/target/vm_fasta.dart' show VmFastaTarget;
 
 /// Cumulative total number of chars scanned.
 int inputSize = 0;
 
 /// Cumulative time spent scanning.
 Stopwatch scanTimer = new Stopwatch();
 
 main(List<String> args) async {
   // TODO(sigmund): provide sdk folder as well.
   if (args.length < 2) {
     print('usage: fasta_perf.dart <bench-id> <entry.dart>');
     exit(1);
   }
   var bench = args[0];
   var entryUri = Uri.base.resolve(args[1]);
 
   await setup(entryUri);
 
   Map<Uri, List<int>> files = await scanReachableFiles(entryUri);
   var handlers = {
     'scan': () async => scanFiles(files),
     // TODO(sigmund): enable when we can run the ast-builder standalone.
     // 'parse': () async => parseFiles(files),
     'kernel_gen_e2e': () async {
       await generateKernel(entryUri);
     },
-    // TODO(sigmund): enable once we add a build step to create the
-    // platform.dill files.
-    // 'kernel_gen_e2e_sum': () async {
-    //   await generateKernel(entryUri, compileSdk: false);
-    // },
+    'kernel_gen_e2e_sum': () async {
+      await generateKernel(entryUri, compileSdk: false);
+    },
   };
 
   var handler = handlers[bench];
   if (handler == null) {
     // TODO(sigmund): implement the remaining benchmarks.
     print('unsupported bench-id: $bench. Please specify one of the following: '
         '${handlers.keys.join(", ")}');
     exit(1);
   }
 
   // TODO(sigmund): replace the warmup with instrumented snapshots.
   int iterations = bench.contains('kernel_gen') ? 2 : 10;
   for (int i = 0; i < iterations; i++) {
     var totalTimer = new Stopwatch()..start();
     print('== iteration $i');
     await handler();
     totalTimer.stop();
     report('total', totalTimer.elapsedMicroseconds);
   }
 }
 
+// TODO(sigmund): use `perf.dart::_findSdkPath` here when fasta can patch the
+// sdk directly.
+Uri sdkRoot =
+    Uri.base.resolve(Platform.resolvedExecutable).resolve('patched_sdk/');
+
 /// Translates `dart:*` and `package:*` URIs to resolved URIs.
 TranslateUri uriResolver;
 
 /// Preliminary set up to be able to correctly resolve URIs on the given
 /// program.
 Future setup(Uri entryUri) async {
-  // TODO(sigmund): use `perf.dart::_findSdkPath` here when fasta can patch the
-  // sdk directly.
-  var sdkRoot =
-      Uri.base.resolve(Platform.resolvedExecutable).resolve('patched_sdk/');
   uriResolver = await TranslateUri.parse(PhysicalFileSystem.instance, sdkRoot);
 }
 
 /// Scan [contents] and return the first token produced by the scanner.
 Token tokenize(List<int> contents) {
   scanTimer.start();
   var token = scan(contents).tokens;
   scanTimer.stop();
   return token;
 }
@@ skipping 66 matching lines @@
   var listener = new DirectiveListenerWithNative();
   new TopLevelParser(listener).parseUnit(tokenize(contents));
   return new Set<String>()
     ..addAll(listener.imports.map((directive) => directive.uri))
     ..addAll(listener.exports.map((directive) => directive.uri))
     ..addAll(listener.parts);
 }
 
 class DirectiveListenerWithNative extends DirectiveListener {
   @override
-  Token handleNativeClause(Token token) => skipNativeClause(token);
+  Token handleNativeClause(Token token) => skipNativeClause(token, true);
 }
 
 /// Parses every file in [files] and reports the time spent doing so.
 void parseFiles(Map<Uri, List<int>> files) {
   scanTimer = new Stopwatch();
   var parseTimer = new Stopwatch()..start();
   files.forEach((uri, source) {
     parseFull(uri, source);
   });
   parseTimer.stop();
@@ skipping 14 matching lines @@
 // bodies. So this listener is not feature complete.
 class _PartialAstBuilder extends AstBuilder {
   _PartialAstBuilder(Uri uri) : super(null, null, null, null, null, true, uri);
 
   // Note: this method converts the body to kernel, so we skip that here.
   @override
   finishFunction(annotations, formals, asyncModifier, body) {}
 }
 
 // Invoke the fasta kernel generator for the program starting in [entryUri]
-// TODO(sigmund): update to use the frontend api once fasta is being hit.
 generateKernel(Uri entryUri,
     {bool compileSdk: true, bool strongMode: false}) async {
   // TODO(sigmund): this is here only to compute the input size,
   // we should extract the input size from the frontend instead.
   scanReachableFiles(entryUri);
 
   var timer = new Stopwatch()..start();
-  final Ticker ticker = new Ticker();
-  final DillTarget dillTarget = new DillTarget(ticker, uriResolver,
-      new VmFastaTarget(new TargetFlags(strongMode: strongMode)));
-  final KernelTarget kernelTarget =
-      new KernelTarget(PhysicalFileSystem.instance, dillTarget, uriResolver);
+  var options = new CompilerOptions()
+    ..sdkRoot = sdkRoot
+    ..chaseDependencies = true
+    ..packagesFileUri = Uri.base.resolve('.packages')
+    ..compileSdk = compileSdk;
+  if (!compileSdk) {
+    options.sdkSummary = sdkRoot.resolve('outline.dill');
+  }
+
   var entrypoints = [
     entryUri,
     // These extra libraries are added to match the same set of libraries
     // scanned by default by the VM and the other benchmarks.
     Uri.parse('dart:async'),
     Uri.parse('dart:collection'),
     Uri.parse('dart:convert'),
     Uri.parse('dart:core'),
     Uri.parse('dart:developer'),
     Uri.parse('dart:_internal'),
     Uri.parse('dart:io'),
     Uri.parse('dart:isolate'),
     Uri.parse('dart:math'),
     Uri.parse('dart:mirrors'),
     Uri.parse('dart:typed_data'),
   ];
-  entrypoints.forEach(kernelTarget.read);
+  var program = await kernelForBuildUnit(entrypoints, options);
 
-  if (!compileSdk) {
-    dillTarget.read(
-        Uri.base.resolve(Platform.resolvedExecutable).resolve('platform.dill'));
-  }
-  await dillTarget.buildOutlines();
-  await kernelTarget.buildOutlines();
-  var program = await kernelTarget.buildProgram();
-  if (kernelTarget.errors.isNotEmpty) {
-    throw kernelTarget.errors.first;
-  }
   timer.stop();
-  report('kernel_gen_e2e', timer.elapsedMicroseconds);
+  var name = 'kernel_gen_e2e${compileSdk ? "" : "_sum"}';
+  report(name, timer.elapsedMicroseconds);
   return program;
 }
 
 /// Report that metric [name] took [time] micro-seconds to process
 /// [inputSize] characters.
 void report(String name, int time) {
   var sb = new StringBuffer();
   var padding = ' ' * (20 - name.length);
   sb.write('$name:$padding $time us, ${time ~/ 1000} ms');
   var invSpeed = (time * 1000 / inputSize).toStringAsFixed(2);
   sb.write(', $invSpeed ns/char');
   print('$sb');
 }