Handle parameters in compile_from_dill_test

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;
 import '../common/names.dart';
@@ skipping 585 matching lines @@
       ..forEach(handleParameter);
 
     // Set the locals handler state as if we were inlining the constructor.
     ConstructorElement astElement = _elementMap.getConstructor(constructor);
     ResolvedAst resolvedAst = astElement.resolvedAst;
     ClosureClassMap oldClosureData = localsHandler.closureData;
     ClosureClassMap newClosureData =
         closureToClassMapper.getMemberMap(astElement);
     localsHandler.closureData = newClosureData;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
-      localsHandler.enterScope(resolvedAst.node,
+      localsHandler.enterScope(newClosureData.capturingScopes[resolvedAst.node],
           forGenerativeConstructorBody: astElement.isGenerativeConstructorBody);
     }
     inlinedFrom(astElement, () {
       _buildInitializers(constructor, constructorChain, fieldValues);
     });
     localsHandler.closureData = oldClosureData;
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction();
     _addClassTypeVariablesIfNeeded(constructor);
     constructor.function.body.accept(this);
     closeFunction();
   }
 
   /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
   /// Procedures.
   void buildFunctionNode(ir.FunctionNode functionNode) {
-    openFunction();
+    Map<Local, TypeMask> parameterMap = <Local, TypeMask>{};
+
+    void handleParameter(ir.VariableDeclaration node) {
+      Local local = _localsMap.getLocal(node);
+      parameterMap[local] = _typeInferenceMap.getInferredTypeOfParameter(local);
+    }
+
+    functionNode.positionalParameters.forEach(handleParameter);
+    functionNode.namedParameters.toList()
+      ..sort(namedOrdering)
+      ..forEach(handleParameter);
+
+    openFunction(parameterMap);
     ir.TreeNode parent = functionNode.parent;
     if (parent is ir.Procedure && parent.kind == ir.ProcedureKind.Factory) {
       _addClassTypeVariablesIfNeeded(functionNode.parent);
     }
 
     // If [functionNode] is `operator==` we explicitly add a null check at the
     // beginning of the method. This is to avoid having call sites do the null
     // check.
     if (parent is ir.Procedure &&
         parent.kind == ir.ProcedureKind.Operator &&
@@ skipping 26 matching lines @@
       currentImplicitInstantiations.add(type);
     }
   }
 
   void removeImplicitInstantiation(DartType type) {
     if (type != null) {
       currentImplicitInstantiations.removeLast();
     }
   }
 
-  void openFunction() {
+  void openFunction(
+      [Map<Local, TypeMask> parameters = const <Local, TypeMask>{}]) {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
-    localsHandler.startFunction(targetElement, functionNode,
+    ClosureClassMap closureData =
+        closureToClassMapper.getMemberMap(targetElement);
+    localsHandler.startFunction(targetElement, closureData,
+        closureData.capturingScopes[functionNode], parameters,
         isGenerativeConstructorBody: _targetIsConstructorBody);
     close(new HGoto()).addSuccessor(block);
 
     open(block);
   }
 
   void closeFunction() {
     if (!isAborted()) closeAndGotoExit(new HGoto());
     graph.finalize();
   }
@@ skipping 2737 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }