compile empty function to ssa from kernel

pkg/compiler/lib/src/ssa/builder_kernel.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/codegen.dart' show CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../elements/elements.dart';
@@ skipping 21 matching lines @@
       AstElement element = work.element.implementation;
       TreeElements treeElements = work.resolvedAst.elements;
       Kernel kernel = new Kernel(backend.compiler);
       KernelVisitor visitor = new KernelVisitor(element, treeElements, kernel);
       IrFunction function;
       try {
         function = visitor.buildFunction();
       } catch (e) {
         throw "Failed to convert to Kernel IR: $e";
       }
-      KernelSsaBuilder builder = new KernelSsaBuilder(function, element,
-          work.resolvedAst, backend.compiler, sourceInformationFactory);
+      KernelSsaBuilder builder = new KernelSsaBuilder(
+          function,
+          element,
+          work.resolvedAst,
+          backend.compiler,
+          sourceInformationFactory,
+          visitor.nodeToElement);
       return builder.build();
     });
   }
 }
 
-// DESIGN NOTE: I am implementing this by essentially copying the methods in
-// [SsaBuilder], but trying to use Kernel IR instead of our AST nodes. In places
-// where there is functionality in the [SsaBuilder] that is not yet needed in
-// this builder, I am adding a comment that tells what the [SsaBuilder] does at
-// that location.
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   final IrFunction function;
   final FunctionElement functionElement;
   final ResolvedAst resolvedAst;
   final Compiler compiler;
+  final Map<ir.Node, Element> nodeToElement;
 
   JavaScriptBackend get backend => compiler.backend;
 
   LocalsHandler localsHandler;
   SourceInformationBuilder sourceInformationBuilder;
 
-  KernelSsaBuilder(this.function, this.functionElement, this.resolvedAst,
-      this.compiler, SourceInformationStrategy sourceInformationFactory) {
+  KernelSsaBuilder(
+      this.function,
+      this.functionElement,
+      this.resolvedAst,
+      this.compiler,
+      SourceInformationStrategy sourceInformationFactory,
+      this.nodeToElement) {
     graph.element = functionElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler =
         new LocalsHandler(this, functionElement, null, compiler);
   }
 
   HGraph build() {
+    // TODO(het): no reason to do this here...
+    HInstruction.idCounter = 0;
     if (function.kind == ir.ProcedureKind.Method) {
       buildMethod(function, functionElement);
     } else {
       compiler.reporter.internalError(
           functionElement,
           "Unable to convert this kind of Kernel "
           "procedure to SSA: ${function.kind}");
     }
     assert(graph.isValid());
     return graph;
   }
 
   /// Builds a SSA graph for [method].
   void buildMethod(IrFunction method, FunctionElement functionElement) {
-    // TODO(het): Determine whether or not this method is called in a loop and
-    // set [graph.isCalledInLoop].
     openFunction(method, functionElement);
+    method.node.body.accept(this);
+    closeFunction();
   }
 
   void openFunction(IrFunction method, FunctionElement functionElement) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
     // TODO(het): Register parameters with a locals handler
     localsHandler.startFunction(functionElement, resolvedAst.node);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
+  }
 
-    // TODO(het): If this is a constructor then add the type parameters of the
-    // enclosing class as parameters to the method. This must be done before
-    // adding normal parameters because their types may contain references to
-    // the class type parameters.
+  void closeFunction() {
+    if (!isAborted()) closeAndGotoExit(new HGoto());
+    graph.finalize();
   }
 }