Implement try/catch without finally, and without type checks.

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 249 matching lines @@
     assert(isAccessedDirectly(element));
     return directLocals[element] !== null;
   }
 
   /**
    * Returns true if the local can be accessed directly. Boxed variables or
    * captured variables that are stored in the closure-field return [false].
    */
   bool isAccessedDirectly(Element element) {
     assert(element !== null);
-    return redirectionMapping[element] === null;
+    return redirectionMapping[element] === null
+        && !closureData.usedVariablesInTry.contains(element);
   }
 
   bool isStoredInClosureField(Element element) {
     assert(element !== null);
     if (isAccessedDirectly(element)) return false;
     Element redirectElement = redirectionMapping[element];
+    if (redirectElement == null) return false;
     if (redirectElement.enclosingElement.kind == ElementKind.CLASS) {
       assert(redirectElement is ClosureFieldElement);
       return true;
     }
     return false;
   }
 
   bool isBoxed(Element element) {
     if (isAccessedDirectly(element)) return false;
     if (isStoredInClosureField(element)) return false;
-    // TODO(floitsch): add some asserts that we really have a boxed element.
-    return true;
+    return redirectionMapping[element] !== null;
+  }
+
+  bool isUsedInTry(Element element) {
+    return closureData.usedVariablesInTry.contains(element);
   }
 
   /**
    * Returns an [HInstruction] for the given element. If the element is
    * boxed or stored in a closure then the method generates code to retrieve
    * the value.
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
         builder.compiler.internalError(
             "Could not find value", node: element.parseNode(builder.compiler));
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       // We must not use the [LocalsHandler.thisDefinition] since that could
       // point to a captured this which would be stored in a closure-field
       // itself.
       HInstruction receiver = new HThis();
       builder.add(receiver);
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
       builder.add(fieldGet);
       return fieldGet;
-    } else {
-      assert(isBoxed(element));
+    } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       HInstruction lookup = new HFieldGet(redirect, box);
       builder.add(lookup);
       return lookup;
+    } else {
+      assert(isUsedInTry(element));
+      HInstruction variable = new HFieldGet.fromActivation(element);
+      builder.add(variable);
+      return variable;
     }
   }
 
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
   void updateLocal(Element element, HInstruction value) {
     // TODO(floitsch): replace the following if with an assert.
     if (element is !VariableElement) {
       builder.compiler.internalError("expected a variable",
                                      node: element.parseNode(builder.compiler));
     }
 
     if (isAccessedDirectly(element)) {
       directLocals[element] = value;
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
       // We must not use the [LocalsHandler.thisDefinition] since that could
       // point to a captured this which would be stored in a closure-field
       // itself.
       HInstruction receiver = new HThis();
       builder.add(receiver);
       builder.add(new HFieldSet(redirect, receiver, value));
-    } else {
-      assert(isBoxed(element));
+    } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
       // be accessed directly.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       builder.add(new HFieldSet(redirect, box, value));
+    } else {
+      assert(isUsedInTry(element));
+      builder.add(new HFieldSet.fromActivation(element,value));
     }
   }
 
   void startLoop(Node node, HBasicBlock loopEntry) {
     ClosureScope scopeData = closureData.capturingScopes[node];
     if (scopeData !== null) {
       builder.compiler.unimplemented("Captured variable in a loop", node: node);
     }
 
     // Create a copy because we modify the map while iterating over
@@ skipping 1326 matching lines @@
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
 
   visitSwitchStatement(SwitchStatement node) {
     compiler.unimplemented('SsaBuilder.visitSwitchStatement', node: node);
   }
 
   visitTryStatement(TryStatement node) {
-    compiler.unimplemented('SsaBuilder.visitTryStatement', node: node);
+    HBasicBlock enterBlock = graph.addNewBlock();
+    close(new HGoto()).addSuccessor(enterBlock);
+    open(enterBlock);
+    close(new HTry());
+
+    HBasicBlock tryBody = graph.addNewBlock();
+    enterBlock.addSuccessor(tryBody);
+    open(tryBody);
+    visit(node.tryBlock);
+    HBasicBlock endTryBlock;
+    if (!isAborted()) endTryBlock = close(new HGoto());

[floitsch, 2012/02/07 17:40:00]

We usually just update the variable:
tryBlock = close(new HGoto());

[ngeoffray, 2012/02/08 09:52:23]

As discussed, renamed the variable to endTryBody.

+
+    List<HBasicBlock> catchBlocks = <HBasicBlock>[];
+    int catchBlocksCount = 0;
+    for (CatchBlock catchBlock in node.catchBlocks.nodes) {
+      if (++catchBlocksCount != 1) {
+        compiler.unimplemented('SsaBuilder multiple catch blocks', node: node);
+      }
+      HBasicBlock block = graph.addNewBlock();
+      enterBlock.addSuccessor(block);
+      open(block);
+      visit(catchBlock);
+      if (!isAborted()) {
+        close(new HGoto());
+        catchBlocks.add(block);
+      }
+    }
+
+    HBasicBlock exitBlock = graph.addNewBlock();
+
+    if (endTryBlock != null) {
+      endTryBlock.addSuccessor(exitBlock);
+    }
+
+    for (HBasicBlock block in catchBlocks) {
+      block.addSuccessor(exitBlock);
+    }
+
+    if (node.finallyBlock != null) {
+      compiler.unimplemented('SsaBuilder finally block', node: node);
+    }
+
+    HBasicBlock joinBlock = graph.addNewBlock();

[floitsch, 2012/02/07 17:40:00]

now that I think about it, I'm not sure we need the joinBlock.

[ngeoffray, 2012/02/08 09:52:23]

Done.

+    open(exitBlock);
+    close(new HGoto()).addSuccessor(joinBlock);
+
+    open(joinBlock);
   }
 
   visitScriptTag(ScriptTag node) {
     compiler.unimplemented('SsaBuilder.visitScriptTag', node: node);
   }
 
   visitCatchBlock(CatchBlock node) {
-    compiler.unimplemented('SsaBuilder.visitCatchBlock', node: node);
+    NodeList formals = node.formals;
+    VariableDefinitions exception = formals.nodes.head;
+    if (exception.type != null) {
+      compiler.unimplemented('SsaBuilder catch with type', node: node);
+    }
+    visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }