Handle closures, aka FunctionExpression in 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 '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         InterceptorConstantValue,
         StringConstantValue,
@@ skipping 90 matching lines @@
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, null, compiler);
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     Element originTarget = targetElement;
     if (originTarget.isPatch) {
       originTarget = originTarget.origin;
     }
     if (originTarget is FunctionElement) {
       target = kernel.functions[originTarget];
+      // Closures require a lookup one level deeper in the closure class mapper.
+      if (target == null) {
+        ClosureClassMap classMap = compiler.closureToClassMapper
+            .getClosureToClassMapping(originTarget.resolvedAst);
+        if (classMap.closureElement != null) {
+          target = kernel.localFunctions[classMap.closureElement];
+        }
+      }
     } else if (originTarget is FieldElement) {
       target = kernel.fields[originTarget];
     }
   }
 
   HGraph build() {
     // TODO(het): no reason to do this here...
     HInstruction.idCounter = 0;
     if (target is ir.Procedure) {
-      buildProcedure(target);
+      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 {
+      throw 'No case implemented to handle $target';
     }
     assert(graph.isValid());
     return graph;
   }
 
   void buildField(ir.Field field) {
     openFunction();
     if (field.initializer != null) {
       field.initializer.accept(this);
     } else {
@@ skipping 186 matching lines @@
     _buildInitializers(constructor, fieldValues);
   }
 
   HTypeConversion buildFunctionTypeConversion(
       HInstruction original, DartType type, int kind) {
     HInstruction reifiedType = buildFunctionType(type);
     return new HTypeConversion.viaMethodOnType(
         type, kind, original.instructionType, reifiedType, original);
   }
 
-  /// Builds a SSA graph for [procedure].
-  void buildProcedure(ir.Procedure procedure) {
+  /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
+  /// Procedures.
+  void buildFunctionNode(ir.FunctionNode functionNode) {
     openFunction();
-    procedure.function.body.accept(this);
+    functionNode.body.accept(this);
     closeFunction();
   }
 
   void addImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.add(type);
     }
   }
 
   void removeImplicitInstantiation(DartType type) {
@@ skipping 75 matching lines @@
     exprStatement.expression.accept(this);
     pop();
   }
 
   @override
   void visitReturnStatement(ir.ReturnStatement returnStatement) {
     HInstruction value;
     if (returnStatement.expression == null) {
       value = graph.addConstantNull(compiler);
     } else {
-      assert(target is ir.Procedure);
+      assert(target is ir.FunctionNode);
       returnStatement.expression.accept(this);
       value = typeBuilder.potentiallyCheckOrTrustType(pop(),
-          astAdapter.getFunctionReturnType((target as ir.Procedure).function));
+          astAdapter.getFunctionReturnType(target));
     }
     // TODO(het): Add source information
     // TODO(het): Set a return value instead of closing the function when we
     // support inlining.
     closeAndGotoExit(new HReturn(value, null));
   }
 
   @override
   void visitForStatement(ir.ForStatement forStatement) {
     assert(isReachable);
@@ skipping 862 matching lines @@
     if (_unexpectedForeignArguments(invocation, 1, 1)) {
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
     List<HInstruction> inputs = _visitArguments(invocation.arguments);
 
     String isolateName = backend.namer.staticStateHolder;
     SideEffects sideEffects = new SideEffects.empty();
     sideEffects.setAllSideEffects();
-    push(new HForeignCode(js.js.parseForeignJS("$isolateName = #"),
-        backend.dynamicType, inputs,
+    push(new HForeignCode(
+        js.js.parseForeignJS("$isolateName = #"), backend.dynamicType, inputs,
         nativeBehavior: native.NativeBehavior.CHANGES_OTHER,
         effects: sideEffects));
   }
 
   void handleForeignJsGetStaticState(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
       stack.add(graph.addConstantNull(compiler)); // Result expected on stack.
       return;
     }
 
@@ skipping 221 matching lines @@
     if (selector.isGetter) {
       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);
+    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);
+  }
+
   // 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();
 
     _pushDynamicInvocation(
@@ skipping 150 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);
   }
 }