dart2js CPS: Fix an incorrect assertion.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
@@ skipping 2129 matching lines @@
   visitSend(ast.Send node) {
     handleSend(node);
     node.visitChildren(this);
   }
 
   visitSendSet(ast.SendSet node) {
     handleSend(node);
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       LocalElement local = element;
-      if (insideInitializer) {
-        assert(local.isParameter);
+      if (insideInitializer &&
+          local.isParameter &&
+          local.enclosingElement == currentFunction) {
+        assert(local.enclosingElement.isConstructor);
         // Initializers in an initializer-list can communicate via parameters.
         // If a parameter is stored in an initializer list we box it.
         // TODO(sigurdm): Fix this.
         // Though these variables do not outlive the activation of the
         // function, they still need to be boxed.  As a simplification, we
         // treat them as if they are captured by a closure (i.e., they do
         // outlive the activation of the function).
         markAsCaptured(local);
       } else if (inTryStatement) {
         assert(local.isParameter || local.isVariable);
         // Search for the position of the try block containing the variable
         // declaration, or -1 if it is declared outside the outermost try.
         int i = tryNestingStack.length - 1;
         while (i >= 0 && !tryNestingStack[i].declared.contains(local)) {
           --i;
         }
         // If there is a next inner try, then the variable should be boxed on
         // entry to it.
         if (i + 1 < tryNestingStack.length) {
           tryNestingStack[i + 1].boxedOnEntry.add(local);
         }
       }
     }
     node.visitChildren(this);
   }
 
   visitFunctionExpression(ast.FunctionExpression node) {
-    FunctionElement oldFunction = currentFunction;
+    FunctionElement savedFunction = currentFunction;
     currentFunction = elements[node];
     if (currentFunction.asyncMarker != AsyncMarker.SYNC) {
       giveup(node, "cannot handle async/sync*/async* functions");
     }
+    bool savedInsideInitializer = insideInitializer;

[karlklose, 2015/08/07 06:00:54]

insideInitializers is always false here, isn't it? I would prefer to assert that
it is false instead to document the invariant that there can only be one
initializer block on stack of function expressions we are visiting

[Kevin Millikin (Google), 2015/08/07 08:37:13]

Yeah, it should be true (that it's always false :) ) in the body of the if block
below.  I won't assert it here because it seems to be more of a general
well-formedness property than something that the correctness of this algorithm
relies on.

     if (node.initializers != null) {
       insideInitializer = true;
       visit(node.initializers);
-      insideInitializer = false;
     }
+    insideInitializer = false;
     visit(node.body);
-    currentFunction = oldFunction;
+    currentFunction = savedFunction;
+    insideInitializer = savedInsideInitializer;
   }
 
   visitTryStatement(ast.TryStatement node) {
     // Try/catch/finally is treated as two simpler constructs: try/catch and
     // try/finally.  The encoding is:
     //
     // try S0 catch (ex, st) S1 finally S2
     // ==>
     // try { try S0 catch (ex, st) S1 } finally S2
     //
@@ skipping 1134 matching lines @@
     if (compiler.backend.isForeign(function)) {
       return handleForeignCode(node, function, argumentList, callStructure);
     } else {
       return irBuilder.buildStaticFunctionInvocation(function, callStructure,
           translateStaticArguments(argumentList, function, callStructure),
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }