If there were breaks in a loop, we must not restore the saved localsHandler before entering the loo…

frog/leg/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 1021 matching lines @@
   }
 
   /**
    * Ends the loop:
    * - creates a new block and adds it as successor to the [branchBlock].
    * - opens the new block (setting as [current]).
    * - notifies the locals handler that we're exiting a loop.
    */
   void endLoop(HBasicBlock loopEntry,
                HBasicBlock branchBlock,
-               BreakHandler breakHandler) {
+               BreakHandler breakHandler,
+               LocalsHandler savedLocals) {
     HBasicBlock loopExitBlock = addNewBlock();
     assert(branchBlock.successors.length == 1);
     List<LocalsHandler> breakLocals = <LocalsHandler>[];
     breakHandler.forEachBreak((HBreak breakInstruction, LocalsHandler locals) {
       breakInstruction.block.addSuccessor(loopExitBlock);
       breakLocals.add(locals);
     });
     branchBlock.addSuccessor(loopExitBlock);
     open(loopExitBlock);
     localsHandler.endLoop(loopEntry);
     if (!breakLocals.isEmpty()) {
       breakLocals.add(localsHandler);

[floitsch, 2012/03/17 22:25:00]

add(savedLocals);

[ngeoffray, 2012/03/18 12:03:45]

Thanks for the suggestion. Done.

       localsHandler = localsHandler.mergeMultiple(breakLocals, loopExitBlock);
+    } else if (savedLocals != null) {
+      localsHandler = savedLocals;
     }
   }
 
   // For while loops, initializer and update are null.
   visitLoop(Node loop, Node initializer, Expression condition, NodeList updates,
             Node body) {
     // Generate:
     //  <initializer>
     //  loop-entry:
     //    if (!<condition>) goto loop-exit;
@@ skipping 59 matching lines @@
         // The result of the update instruction isn't used, and can just
         // be dropped.
         HInstruction updateInstruction = pop();
       }
     }
     updateBlock = close(new HGoto());
     // The back-edge completing the cycle.
     updateBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
 
-    endLoop(conditionBlock, conditionExitBlock, breakHandler);
-    localsHandler = savedLocals;
+    endLoop(conditionBlock, conditionExitBlock, breakHandler, savedLocals);
   }
 
   visitFor(For node) {
     assert(node.body !== null);
     visitLoop(node, node.initializer, node.condition, node.update, node.body);
   }
 
   visitWhile(While node) {
     visitLoop(node, null, node.condition, null, node.body);
   }
@@ skipping 13 matching lines @@
     bodyExitBlock.addSuccessor(conditionBlock);
     open(conditionBlock);
     visit(node.condition);
     assert(!isAborted());
     conditionBlock = close(new HLoopBranch(popBoolified(),
                                            HLoopBranch.DO_WHILE_LOOP));
 
     conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
-    endLoop(loopEntryBlock, conditionBlock, breakHandler);
+    endLoop(loopEntryBlock, conditionBlock, breakHandler, null);

[floitsch, 2012/03/17 22:25:00]

localsHandler

[ngeoffray, 2012/03/18 12:03:45]

Done.

   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureData nestedClosureData = closureDataCache[node];
     assert(nestedClosureData !== null);
     assert(nestedClosureData.closureClassElement !== null);
     ClassElement closureClassElement =
         nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
     compiler.enqueue(new WorkItem.toCodegen(callElement, elements));
@@ skipping 1007 matching lines @@
     // update block is the jump-target for continue statements. We could avoid
     // the creation if there is no continue, but for now we always create it.
     HBasicBlock updateBlock = addNewBlock();
     bodyBlock.addSuccessor(updateBlock);
     open(updateBlock);
     updateBlock = close(new HGoto());
     // The back-edge completing the cycle.
     updateBlock.addSuccessor(conditionBlock);
     conditionBlock.postProcessLoopHeader();
 
-    endLoop(conditionBlock, conditionExitBlock, breakHandler);
-    localsHandler = savedLocals;
+    endLoop(conditionBlock, conditionExitBlock, breakHandler, savedLocals);
     breakHandler.close();
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.getBody();
     if (body is Loop || body is SwitchStatement) {
       // Loops and switches handle their own labels.
       visit(body);
       return;
     }
@@ skipping 336 matching lines @@
     buildBody() {
       // TODO(lrn): Make sure to take continue into account.
       visit(body);
       if (isAborted()) {
         compiler.reportWarning(body, "aborting loop body");
       }
     }
     handleIf(buildBody, null);
   }
 }