A return and a throw should empty the environment.

frog/leg/ssa/bailout.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 BailoutInfo {
   int instructionId;
   int bailoutId;
   BailoutInfo(this.instructionId, this.bailoutId);
 }
 
@@ skipping 19 matching lines @@
         add(instruction.inputs[i]);
       }
     }
   }
 
   void addAll(Environment other) {
     lives.addAll(other.lives);
   }
 
   List<HInstruction> buildAndSetLast(HInstruction instruction) {
-    remove(instruction);

[floitsch, 2012/02/22 17:22:32]

keep.

     List<HInstruction> result = new List<HInstruction>.from(lives);
     result.addLast(instruction);
-    add(instruction);
     return result;
   }
 
   bool isEmpty() => lives.isEmpty();
   bool contains(HInstruction instruction) => lives.contains(instruction);
+  void clear() => lives.clear();
 }
 
 /**
  * Computes the environment for each SSA instruction: visits the graph
  * in post-dominator order. Removes an instruction from the environment
  * and adds its inputs to the environment at the instruction's
  * definition.
  */
 class SsaEnvironmentBuilder extends HBaseVisitor {
   final Compiler compiler;
@@ skipping 134 matching lines @@
 
     if (!branch.isDoWhile()) {
       assert(block.successors[0] == block.dominatedBlocks[0]);
       visitBasicBlock(block.successors[0]);
     }
   }
 
   // Deal with all kinds of control flow instructions. In case we add
   // a new one, we will hit an internal error.
   void visitExit(HExit exit) {}
-  void visitReturn(HReturn instruction) {}
-  void visitThrow(HThrow instruction) {}
+
+  void visitReturn(HReturn instruction) {
+    environment.clear();
+    visitInstruction(instruction);
+  }
+
+  void visitThrow(HThrow instruction) {
+    environment.clear();
+    visitInstruction(instruction);
+  }
 
   void visitControlFlow(HControlFlow instruction) {
     compiler.internalError('Control flow instructions already dealt with.',
                            instruction: instruction);
   }
 }
 
 /**
  * Visits the graph and replaces guards with guards that capture the
  * environment.
  */
 class SsaTypeGuardBuilder extends SsaEnvironmentBuilder {
 
   SsaTypeGuardBuilder(Compiler compiler) : super(compiler);
 
-  HInstruction tryInsertTypeGuard(HInstruction instruction,
-                                  HInstruction insertionPoint) {
+  void tryInsertTypeGuard(HInstruction instruction,
+                          HInstruction insertionPoint) {
     // If we found a type for the instruction, but the instruction
     // does not know if it produces that type, add a type guard.
     if (instruction.type.isKnown() && !instruction.hasExpectedType()) {
       // The type guard expects the guarded instruction to be at the
       // end of the inputs.
       List<HInstruction> inputs = environment.buildAndSetLast(instruction);
       HTypeGuard guard =
           new HTypeGuard(instruction.type, inputs, instruction.id);
       // Remove the instruction's type, the guard is now holding that
       // type.
@@ skipping 108 matching lines @@
     compiler.internalError('Control flow instructions already dealt with.',
                            instruction: instruction);
   }
 
   visitBailoutTarget(HBailoutTarget target) {
     blocks.forEach((HBasicBlock block) {
       block.bailouts.add(target);
     });
   }
 }