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 231 matching lines @@
   ///
   ///  7. Walk inheritance chain to call or inline constructor bodies.
   ///
   /// All the bindings are put in the constructor's locals handler. The
   /// implication is that a class cannot be extended or mixed-in twice. If we in
   /// future support repeated uses of a mixin class, we should do so by cloning
   /// the mixin class in the Kernel input.
   void buildConstructor(ir.Constructor constructor) {
     ir.Class constructedClass = constructor.enclosingClass;
 
-    openFunction();
+    openFunction(constructor.function);
     _addClassTypeVariablesIfNeeded(constructor);
 
     // TODO(sra): Type parameter constraint checks.
 
     // TODO(sra): Checked mode parameter checks.
 
     // Collect field values for the current class.
     Map<FieldEntity, HInstruction> fieldValues =
         _collectFieldValues(constructedClass);
     List<ir.Constructor> constructorChain = <ir.Constructor>[];
@@ skipping 333 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();
+    openFunction(constructor.function);
     _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();
+    openFunction(functionNode);
     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([ir.FunctionNode function]) {
+    Map<Local, TypeMask> parameterMap = <Local, TypeMask>{};
+    if (function != null) {
+      void handleParameter(ir.VariableDeclaration node) {
+        Local local = _localsMap.getLocal(node);
+        parameterMap[local] =
+            _typeInferenceMap.getInferredTypeOfParameter(local);
+      }
+
+      function.positionalParameters.forEach(handleParameter);
+      function.namedParameters.toList()
+        ..sort(namedOrdering)
+        ..forEach(handleParameter);
+    }
+
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
-    localsHandler.startFunction(targetElement, functionNode,
+    ClosureClassMap closureData =
+        closureToClassMapper.getMemberMap(targetElement);
+    localsHandler.startFunction(targetElement, closureData,
+        closureData.capturingScopes[functionNode], parameterMap,
         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;
   }
 }