Check closure data for serialization

pkg/compiler/lib/src/ssa/builder.dart

 // Copyright (c) 2012, 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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 494 matching lines @@
     }
     return res;
   }
 
   HLocalValue getLocal(Local local, {SourceInformation sourceInformation}) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
-    if (local is ParameterElement) return builder.parameters[local];
+    if (local is ParameterElement) {
+      assert(invariant(local, builder.parameters.containsKey(local),
+          message: "No local value for parameter $local in "
+              "${builder.parameters}."));
+      return builder.parameters[local];
+    }
 
     return builder.activationVariables.putIfAbsent(local, () {
       JavaScriptBackend backend = builder.backend;
       HLocalValue localValue = new HLocalValue(local, backend.nonNullType)
         ..sourceInformation = sourceInformation;
       builder.graph.entry.addAtExit(localValue);
       return localValue;
     });
   }
 
@@ skipping 1268 matching lines @@
       if (backendMember.isGenerativeConstructorBody) {
         ConstructorBodyElement body = backendMember;
         if (body.constructor == constructor) {
           // TODO(kasperl): Find a way of stopping the iteration
           // through the backend members.
           bodyElement = backendMember;
         }
       }
     });
     if (bodyElement == null) {
-      bodyElement = new ConstructorBodyElementX(constructor);
+      bodyElement =
+          new ConstructorBodyElementX(constructorResolvedAst, constructor);
       classElement.addBackendMember(bodyElement);
 
       if (constructor.isPatch) {
         // Create origin body element for patched constructors.
         ConstructorBodyElementX patch = bodyElement;
-        ConstructorBodyElementX origin =
-            new ConstructorBodyElementX(constructor.origin);
+        ConstructorBodyElementX origin = new ConstructorBodyElementX(
+            constructorResolvedAst, constructor.origin);
         origin.applyPatch(patch);
         classElement.origin.addBackendMember(bodyElement.origin);
       }
     }
     assert(bodyElement.isGenerativeConstructorBody);
     return bodyElement;
   }
 
   HParameterValue addParameter(Entity parameter, TypeMask type) {
     assert(inliningStack.isEmpty);
@@ skipping 6778 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }