build kernel for the entire program after resolution

pkg/compiler/lib/src/ssa/kernel_impact.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../kernel/kernel_visitor.dart';
 import '../resolution/registry.dart' show ResolutionWorldImpactBuilder;
 import '../universe/feature.dart';
 import '../universe/use.dart';
 
 import 'kernel_ast_adapter.dart';
 import '../common/resolution.dart';
 
 /// Computes the [ResolutionImpact] for [resolvedAst] through kernel.
 ResolutionImpact build(Compiler compiler, ResolvedAst resolvedAst) {
   AstElement element = resolvedAst.element.implementation;
-  Kernel kernel = new Kernel(compiler);
-  KernelVisitor visitor =
-      new KernelVisitor(element, resolvedAst.elements, kernel);
-  IrFunction function;
-  try {
-    function = visitor.buildFunction();
-  } catch (e) {
-    throw "Failed to convert to Kernel IR: $e";
+//  Kernel kernel = new Kernel(compiler);

[Siggi Cherem (dart-lang), 2016/09/09 22:49:23]

ditto?

[Harry Terkelsen, 2016/09/09 22:56:47]

Done.

+//  KernelVisitor visitor =
+//      new KernelVisitor(element, resolvedAst.elements, kernel);
+//  IrFunction function;
+//  try {
+//    function = visitor.buildFunction();
+//  } catch (e) {
+//    throw "Failed to convert to Kernel IR: $e";
+//  }
+  JavaScriptBackend backend = compiler.backend;
+  Kernel kernel = backend.kernelTask.kernel;
+  ir.Procedure function = kernel.functions[element];
+  if (function == null) {
+    print("FOUND NULL FUNCTION: $element");
+    print(kernel.functions);
   }
-  KernelImpactBuilder builder = new KernelImpactBuilder(
-      function, element, resolvedAst, compiler, visitor, kernel);
+  KernelImpactBuilder builder =
+      new KernelImpactBuilder(function, element, resolvedAst, compiler, kernel);
   return builder.build();
 }
 
 class KernelImpactBuilder extends ir.Visitor {
-  final IrFunction function;
+  final ir.Procedure function;
   final FunctionElement functionElement;
   final ResolvedAst resolvedAst;
   final Compiler compiler;
 
   JavaScriptBackend get backend => compiler.backend;
 
   ResolutionWorldImpactBuilder impactBuilder;
   KernelAstAdapter astAdapter;
 
   KernelImpactBuilder(this.function, this.functionElement, this.resolvedAst,
-      this.compiler, KernelVisitor visitor, Kernel kernel) {
+      this.compiler, Kernel kernel) {
     this.impactBuilder = new ResolutionWorldImpactBuilder('$functionElement');
     this.astAdapter = new KernelAstAdapter(
         compiler.backend,
         resolvedAst,
-        visitor.nodeToAst,
-        visitor.nodeToElement,
+        kernel.nodeToAst,
+        kernel.nodeToElement,
         kernel.functions,
         kernel.classes,
         kernel.libraries);
   }
 
   ResolutionImpact build() {
     if (function.kind == ir.ProcedureKind.Method ||
         function.kind == ir.ProcedureKind.Operator) {
       buildMethod(function);
     } else {
       compiler.reporter.internalError(
           functionElement,
           "Unable to compute resolution impact for this kind of Kernel "
           "procedure: ${function.kind}");
     }
     return impactBuilder;
   }
 
   /// Add a checked-mode type use of [type] if it is not `dynamic`.
   DartType checkType(DartType type) {
     if (!type.isDynamic) {
       impactBuilder.registerTypeUse(new TypeUse.checkedModeCheck(type));
     }
     return type;
   }
 
-  void buildMethod(IrFunction method) {
-    method.node.body.accept(this);
+  void buildMethod(ir.Procedure method) {
+    method.function.body.accept(this);
   }
 
   void visitNodes(Iterable<ir.Node> nodes) {
     nodes.forEach((ir.Node node) => node.accept(this));
   }
 
   @override
   void visitBlock(ir.Block block) => visitNodes(block.statements);
 
   @override
@@ skipping 98 matching lines @@
     _visitArguments(invocation.arguments);
     impactBuilder.registerDynamicUse(
         new DynamicUse(astAdapter.getSelector(invocation), null));
   }
 
   @override
   void visitNot(ir.Not not) {
     not.operand.accept(this);
   }
 }