Improve exception handling:

dart/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 71 matching lines @@
     return compiler.findHelper(const SourceString('index'));
   }
 
   Element getIndexAssignmentInterceptor() {
     return compiler.findHelper(const SourceString('indexSet'));
   }
 
   Element getEqualsNullInterceptor() {
     return compiler.findHelper(const SourceString('eqNull'));
   }
+
+  Element getExceptionUnwrapper() {
+    return compiler.findHelper(const SourceString('unwrapException'));
+  }
 }
 
 class SsaBuilderTask extends CompilerTask {
   SsaBuilderTask(Compiler compiler)
     : super(compiler), interceptors = new Interceptors(compiler);
   String get name() => 'SSA builder';
   Interceptors interceptors;
 
   HGraph build(WorkItem work) {
     return measure(() {
@@ skipping 519 matching lines @@
 }
 
 class SsaBuilder implements Visitor {
   final Compiler compiler;
   TreeElements elements;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
+  HInstruction rethrowableException;
 
   Map<StatementElement, BreakHandler> breakTargets;
 
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
 
@@ skipping 1247 matching lines @@
       value = graph.addNewLiteralNull();
     } else {
       visit(node.expression);
       value = pop();
     }
     close(new HReturn(value)).addSuccessor(graph.exit);
   }
 
   visitThrow(Throw node) {
     if (node.expression === null) {
-      compiler.unimplemented("SsaBuilder: throw without expression");
+      HInstruction exception = rethrowableException;
+      if (exception === null) {
+        exception = graph.addNewLiteralNull();
+        compiler.reportError(node,
+                             'throw without expression outside catch block');
+      }
+      close(new HThrow(exception, isRethrow: true));
+    } else {
+      visit(node.expression);
+      close(new HThrow(pop()));
     }
-    visit(node.expression);
-    close(new HThrow(pop()));
   }
 
   visitTypeAnnotation(TypeAnnotation node) {
     compiler.internalError('visiting type annotation in SSA builder',
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     for (Link<Node> link = node.definitions.nodes;
          !link.isEmpty();
@@ skipping 94 matching lines @@
     if (node.target === null) {
       breakInstruction = new HBreak();
     }  else {
       breakInstruction = new HBreak(node.target.source);
     }
     close(breakInstruction);
     handler.addBreak(breakInstruction, savedLocals);
   }
 
   visitContinueStatement(ContinueStatement node) {
-    compiler.unimplemented('SsaBuilder.visitContinueStatement', node: node);
+    // TODO(lrn): Replace this with a real implementation of continue.
+    compiler.reportWarning(node, 'continue not implemented');
+    DartString string = new DartString.literal('continue not implemented');
+    HInstruction message = graph.addNewLiteralString(string);
+    close(new HThrow(message));
   }
 
   BreakHandler getLoopBreakHandler(Loop node) {
     StatementElement element = elements[node];
     BreakHandler handler;
     if (loopBreakHandler === null) {
       if (element === null) return const NullBreakHandler();
       handler = new BreakHandler(this);
     } else {
       handler = loopBreakHandler;
@@ skipping 173 matching lines @@
 
     if (!node.catchBlocks.isEmpty()) {
       HBasicBlock block = graph.addNewBlock();
       enterBlock.addSuccessor(block);
       open(block);
       // Note that the name of this element is irrelevant.
       Element element = new Element(
           const SourceString('exception'), ElementKind.PARAMETER, work.element);
       HParameterValue exception = new HParameterValue(element);
       add(exception);
+      HInstruction oldRethrowableException = rethrowableException;
+      rethrowableException = exception;
+      push(new HStatic(interceptors.getExceptionUnwrapper()));
+      List<HInstruction> inputs = <HInstruction>[pop(), exception];
+      HInvokeStatic unwrappedException =
+        new HInvokeStatic(Selector.INVOCATION_1, inputs);
+      add(unwrappedException);
+
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         VariableDefinitions declaration = catchBlock.formals.nodes.head;
         HInstruction condition = null;
         if (declaration.type == null) {
           condition = graph.addNewLiteralTrue();
           stack.add(condition);
         } else {
           Element typeElement = elements[declaration.type];
           if (typeElement == null) {
             compiler.cancel('Catch with unresolved type', node: catchBlock);
           }
-          condition = new HIs(typeElement, exception);
+          condition = new HIs(typeElement, unwrappedException);
           push(condition);
         }
       }
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
         VariableDefinitions declaration = catchBlock.formals.nodes.head;
         localsHandler.updateLocal(elements[declaration.definitions.nodes.head],
-                                  exception);
+                                  unwrappedException);
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty()) {
-          close(new HThrow(exception));
+          close(new HThrow(exception, isRethrow: true));
         } else {
           CatchBlock newBlock = link.head;
           pushCondition(newBlock);
           handleIf(visitThen, visitElse);
         }
       }
 
       CatchBlock firstBlock = link.head;
       pushCondition(firstBlock);
       handleIf(visitThen, visitElse);
       if (!isAborted()) blocks.add(close(new HGoto()));
+      rethrowableException = oldRethrowableException;
     }
 
     if (node.finallyBlock != null) {
       HBasicBlock finallyBlock = graph.addNewBlock();
       enterBlock.addSuccessor(finallyBlock);
       open(finallyBlock);
       visit(node.finallyBlock);
       if (!isAborted()) blocks.add(close(new HGoto()));
       tryInstruction.finallyBlock = finallyBlock;
     }
@@ skipping 12 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }