Revert "[vm, bytecode] Use CoreTypes and ClassHierarchy from non-incremental front end results when generating bytecode."

This reverts commit f2c882b.

Reason for revert: batch mode failures

Original change's description:
> [vm, bytecode] Use CoreTypes and ClassHierarchy from non-incremental front end results when generating bytecode.
> 
> Change-Id: I9a8b2530009ff6cc6880ee177a6bee4bb9101e82
> Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/120626
> Commit-Queue: Ryan Macnak <rmacnak@google.com>
> Reviewed-by: Alexander Markov <alexmarkov@google.com>

TBR=rmacnak@google.com,alexmarkov@google.com

Change-Id: I8ea8e155af0d2a4c4382107d723f7bf8a50dc3d7
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/120748
Reviewed-by: Ryan Macnak <rmacnak@google.com>
Commit-Queue: Ryan Macnak <rmacnak@google.com>

Author: rmacnak-google

pkg/frontend_server/lib/frontend_server.dart

@@ -34,7 +34,6 @@ import 'package:vm/bytecode/options.dart' show BytecodeOptions;
 import 'package:vm/incremental_compiler.dart' show IncrementalCompiler;
 import 'package:vm/kernel_front_end.dart'
     show
-        KernelCompilationResults,
         asFileUri,
         compileToKernel,
         convertFileOrUriArgumentToUri,
@@ -379,21 +378,17 @@ class FrontendCompiler implements CompilerInterface {
     _compilerOptions = compilerOptions;
     _bytecodeOptions = bytecodeOptions;
 
-    KernelCompilationResults results;
+    Component component;
+    Iterable<Uri> compiledSources;
     if (options['incremental']) {
       setVMEnvironmentDefines(environmentDefines, _compilerOptions);
 
       _compilerOptions.omitPlatform = false;
       _generator =
           generator ?? _createGenerator(new Uri.file(_initializeFromDill));
       await invalidateIfInitializingFromDill();
-      Component component =
-          await _runWithPrintRedirection(() => _generator.compile());
-      results = new KernelCompilationResults(
-          component,
-          _generator.getClassHierarchy(),
-          _generator.getCoreTypes(),
-          component.uriToSource.keys);
+      component = await _runWithPrintRedirection(() => _generator.compile());
+      compiledSources = component.uriToSource.keys;
     } else {
       if (options['link-platform']) {
         // TODO(aam): Remove linkedDependencies once platform is directly embedded
@@ -403,28 +398,30 @@ class FrontendCompiler implements CompilerInterface {
         ];
       }
       // No bytecode at this step. Bytecode is generated later in _writePackage.
-      results = await _runWithPrintRedirection(() => compileToKernel(
+      final results = await _runWithPrintRedirection(() => compileToKernel(
           _mainSource, compilerOptions,
           aot: options['aot'],
           useGlobalTypeFlowAnalysis: options['tfa'],
           environmentDefines: environmentDefines,
           useProtobufTreeShaker: options['protobuf-tree-shaker']));
+      component = results.component;
+      compiledSources = results.compiledSources;
     }
-    if (results.component != null) {
+    if (component != null) {
       if (transformer != null) {
-        transformer.transform(results.component);
+        transformer.transform(component);
       }
 
-      await writeDillFile(results, _kernelBinaryFilename,
+      await writeDillFile(component, _kernelBinaryFilename,
           filterExternal: importDill != null);
 
       _outputStream.writeln(boundaryKey);
-      await _outputDependenciesDelta(results.compiledSources);
+      await _outputDependenciesDelta(compiledSources);
       _outputStream
           .writeln('$boundaryKey $_kernelBinaryFilename ${errors.length}');
       final String depfile = options['depfile'];
       if (depfile != null) {
-        await writeDepfile(compilerOptions.fileSystem, results.compiledSources,
+        await writeDepfile(compilerOptions.fileSystem, compiledSources,
             _kernelBinaryFilename, depfile);
       }
 
@@ -480,9 +477,8 @@ class FrontendCompiler implements CompilerInterface {
     previouslyReportedDependencies = uris;
   }
 
-  writeDillFile(KernelCompilationResults results, String filename,
+  writeDillFile(Component component, String filename,
       {bool filterExternal: false}) async {
-    final Component component = results.component;
     // Remove the cache that came either from this function or from
     // initializing from a kernel file.
     component.metadata.remove(BinaryCacheMetadataRepository.repositoryTag);
@@ -496,10 +492,10 @@ class FrontendCompiler implements CompilerInterface {
           if (_options['incremental']) {
             await forEachPackage(component,
                 (String package, List<Library> libraries) async {
-              _writePackage(results, package, libraries, sink);
+              _writePackage(component, package, libraries, sink);
             });
           } else {
-            _writePackage(results, 'main', component.libraries, sink);
+            _writePackage(component, 'main', component.libraries, sink);
           }
         });
         await sink.close();
@@ -606,7 +602,7 @@ class FrontendCompiler implements CompilerInterface {
     }
   }
 
-  void _writePackage(KernelCompilationResults result, String package,
+  void _writePackage(Component component, String package,
       List<Library> libraries, IOSink sink) {
     final canCache = libraries.isNotEmpty &&
         _compilerOptions.bytecode &&
@@ -621,7 +617,7 @@ class FrontendCompiler implements CompilerInterface {
       }
     }
 
-    Component partComponent = result.component;
+    Component partComponent = component;
     if (_compilerOptions.bytecode && errors.isEmpty) {
       generateBytecode(partComponent,
           options: _bytecodeOptions,
@@ -655,22 +651,17 @@ class FrontendCompiler implements CompilerInterface {
       _mainSource = _getFileOrUri(entryPoint);
     }
     errors.clear();
-
     Component deltaProgram = await _generator.compile(entryPoint: _mainSource);
+
     if (deltaProgram != null && transformer != null) {
       transformer.transform(deltaProgram);
     }
+    final compiledSources = deltaProgram.uriToSource.keys;
 
-    KernelCompilationResults results = new KernelCompilationResults(
-        deltaProgram,
-        _generator.getClassHierarchy(),
-        _generator.getCoreTypes(),
-        deltaProgram.uriToSource.keys);
-
-    await writeDillFile(results, _kernelBinaryFilename);
+    await writeDillFile(deltaProgram, _kernelBinaryFilename);
 
     _outputStream.writeln(boundaryKey);
-    await _outputDependenciesDelta(results.compiledSources);
+    await _outputDependenciesDelta(compiledSources);
     _outputStream
         .writeln('$boundaryKey $_kernelBinaryFilename ${errors.length}');
     _kernelBinaryFilename = _kernelBinaryFilenameIncremental;

pkg/vm/lib/kernel_front_end.dart

@@ -250,8 +250,6 @@ Future<int> runCompiler(ArgResults options, String usage) async {
       mainUri,
       compilerOptions,
       results.component,
-      results.coreTypes,
-      results.classHierarchy,
       outputFileName,
       genBytecode: genBytecode,
       bytecodeOptions: bytecodeOptions,
@@ -266,12 +264,9 @@ Future<int> runCompiler(ArgResults options, String usage) async {
 /// collection of compiled sources.
 class KernelCompilationResults {
   final Component component;
-  final ClassHierarchy classHierarchy;
-  final CoreTypes coreTypes;
   final Iterable<Uri> compiledSources;
 
-  KernelCompilationResults(this.component, this.classHierarchy, this.coreTypes,
-      this.compiledSources);
+  KernelCompilationResults(this.component, this.compiledSources);
 }
 
 /// Generates a kernel representation of the program whose main library is in
@@ -295,7 +290,6 @@ Future<KernelCompilationResults> compileToKernel(
 
   setVMEnvironmentDefines(environmentDefines, options);
   CompilerResult compilerResult = await kernelForProgram(source, options);
-
   Component component = compilerResult?.component;
   final compiledSources = component?.uriToSource?.keys;
 
@@ -313,10 +307,7 @@ Future<KernelCompilationResults> compileToKernel(
 
   if (genBytecode && !errorDetector.hasCompilationErrors && component != null) {
     await runWithFrontEndCompilerContext(source, options, component, () {
-      generateBytecode(component,
-          hierarchy: compilerResult.classHierarchy,
-          coreTypes: compilerResult.coreTypes,
-          options: bytecodeOptions);
+      generateBytecode(component, options: bytecodeOptions);
     });
 
     if (dropAST) {
@@ -327,8 +318,7 @@ Future<KernelCompilationResults> compileToKernel(
   // Restore error handler (in case 'options' are reused).
   options.onDiagnostic = errorDetector.previousErrorHandler;
 
-  return new KernelCompilationResults(component, compilerResult.classHierarchy,
-      compilerResult.coreTypes, compiledSources);
+  return new KernelCompilationResults(component, compiledSources);
 }
 
 void setVMEnvironmentDefines(
@@ -600,8 +590,6 @@ Future writeOutputSplitByPackages(
   Uri source,
   CompilerOptions compilerOptions,
   Component component,
-  CoreTypes coreTypes,
-  ClassHierarchy hierarchy,
   String outputFileName, {
   bool genBytecode: false,
   BytecodeOptions bytecodeOptions,
@@ -611,6 +599,14 @@ Future writeOutputSplitByPackages(
     BytecodeSizeStatistics.reset();
   }
 
+  ClassHierarchy hierarchy;
+  if (genBytecode) {
+    // Calculating class hierarchy is an expensive operation.
+    // Calculate it once and reuse while generating bytecode for each package.
+    hierarchy =
+        new ClassHierarchy(component, onAmbiguousSupertypes: (cls, a, b) {});
+  }
+
   final packages = new List<String>();
   await runWithFrontEndCompilerContext(source, compilerOptions, component,
       () async {
@@ -625,8 +621,7 @@ Future writeOutputSplitByPackages(
         generateBytecode(partComponent,
             options: bytecodeOptions,
             libraries: libraries,
-            hierarchy: hierarchy,
-            coreTypes: coreTypes);
+            hierarchy: hierarchy);
 
         if (dropAST) {
           partComponent = createFreshComponentWithBytecode(partComponent);