Now also support FunctionDeclarations instead of just closures.

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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 123 matching lines @@
     if (target is ir.Procedure) {
       target = (target as ir.Procedure).function;
       buildFunctionNode(target);
     } else if (target is ir.Field) {
       buildField(target);
     } else if (target is ir.Constructor) {
       buildConstructor(target);
     } else if (target is ir.FunctionExpression) {
       target = (target as ir.FunctionExpression).function;
       buildFunctionNode(target);
+    } else if (target is ir.FunctionDeclaration) {
+      target = (target as ir.FunctionDeclaration).function;
+      buildFunctionNode(target);

[sra1, 2016/12/06 23:26:15]

why not:

buildFunctionNode(target.function);

you have to do this everywhere so there are no assignments to destroy the value
of type propagation

     } else {
       throw 'No case implemented to handle $target';
     }
     assert(graph.isValid());
     return graph;
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
@@ skipping 1489 matching lines @@
       push(new HInvokeDynamicGetter(selector, mask, null, inputs, type));
     } else if (selector.isSetter) {
       push(new HInvokeDynamicSetter(selector, mask, null, inputs, type));
     } else {
       push(new HInvokeDynamicMethod(
           selector, mask, inputs, type, isIntercepted));
     }
   }
 
   @override
-  void visitFunctionExpression(ir.FunctionExpression funcExpression) {
-    LocalFunctionElement methodElement = astAdapter.getElement(funcExpression);
+  visitFunctionNode(ir.FunctionNode node) {
+    LocalFunctionElement methodElement = astAdapter.getElement(node);
     ClosureClassMap nestedClosureData = compiler.closureToClassMapper
         .getClosureToClassMapping(methodElement.resolvedAst);
     assert(nestedClosureData != null);
     assert(nestedClosureData.closureClassElement != null);
     ClosureClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
     // TODO(ahe): This should be registered in codegen, not here.
     // TODO(johnniwinther): Is [registerStaticUse] equivalent to
     // [addToWorkList]?
     registry?.registerStaticUse(new StaticUse.foreignUse(callElement));
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type =
         new TypeMask.nonNullExact(closureClassElement, compiler.closedWorld);
     // TODO(efortuna): Add source information here.
     push(new HCreate(closureClassElement, capturedVariables, type));
 
     registry?.registerInstantiatedClosure(methodElement);
   }
 
+  @override
+  visitFunctionDeclaration(ir.FunctionDeclaration declaration) {
+    assert(isReachable);
+    declaration.function.accept(this);
+    LocalFunctionElement localFunction = astAdapter.getElement(
+        declaration.function);
+    //LocalFunctionElement localFunction =
+    //    elements.getFunctionDefinition(declaration.function);

[sra1, 2016/12/06 23:26:15]

comment

+    localsHandler.updateLocal(localFunction, pop());
+  }
+
+  @override
+  void visitFunctionExpression(ir.FunctionExpression funcExpression) {
+    funcExpression.function.accept(this);
+  }
+
   // TODO(het): Decide when to inline
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     // Handle `x == null` specially. When these come from null-aware operators,
     // there is no mapping in the astAdapter.
     if (_handleEqualsNull(invocation)) return;
     invocation.receiver.accept(this);
     HInstruction receiver = pop();
     Selector selector = astAdapter.getSelector(invocation);
     _pushDynamicInvocation(
@@ skipping 154 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }