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 76 matching lines @@
 
 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(() {
       FunctionElement element = work.element;
-      TreeElements elements = work.resolutionTree;
       HInstruction.idCounter = 0;
-      SsaBuilder builder = new SsaBuilder(compiler, elements);
+      SsaBuilder builder = new SsaBuilder(compiler, work);
       HGraph graph;
       switch (element.kind) {
         case ElementKind.GENERATIVE_CONSTRUCTOR:
           graph = compileConstructor(builder, work);
           break;
         case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
         case ElementKind.FUNCTION:
         case ElementKind.GETTER:
         case ElementKind.SETTER:
           graph = builder.buildMethod(work.element);
@@ skipping 150 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 36 matching lines @@
       }
     });
     directLocals = joinedLocals;
   }
 }
 
 class SsaBuilder implements Visitor {
   final Compiler compiler;
   final TreeElements elements;
   final Interceptors interceptors;
+  final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
 
   // 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;
 
-  SsaBuilder(Compiler compiler, this.elements)
+  SsaBuilder(Compiler compiler, WorkItem work)
     : this.compiler = compiler,
+      this.work = work,
       interceptors = compiler.builder.interceptors,
       methodInterceptionEnabled = true,
+      elements = work.resolutionTree,
       graph = new HGraph(),
       stack = new List<HInstruction>() {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
@@ skipping 1255 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);
+    work.allowSpeculativeOptimization = false;
+    assert(!work.isBailoutVersion());
+    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 endTryBody;
+    if (!isAborted()) endTryBody = close(new HGoto());
+
+    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 (endTryBody != null) {
+      endTryBody.addSuccessor(exitBlock);
+    }
+
+    for (HBasicBlock block in catchBlocks) {
+      block.addSuccessor(exitBlock);
+    }
+
+    if (node.finallyBlock != null) {
+      compiler.unimplemented('SsaBuilder finally block', node: node);
+    }
+
+    open(exitBlock);
   }
 
   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);
   }
 }