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

frog/leg/ssa/nodes.dart

 // Copyright (c) 2011, 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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 40 matching lines @@
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
   R visitStatic(HStatic node);
   R visitStaticStore(HStaticStore node);
   R visitStore(HStore node);
   R visitSubtract(HSubtract node);
   R visitThis(HThis node);
   R visitThrow(HThrow node);
   R visitTruncatingDivide(HTruncatingDivide node);
+  R visitTry(HTry node);
   R visitTypeGuard(HTypeGuard node);
 }
 
 class HGraphVisitor {
   visitDominatorTree(HGraph graph) {
     void visitBasicBlockAndSuccessors(HBasicBlock block) {
       visitBasicBlock(block);
       List dominated = block.dominatedBlocks;
       for (int i = 0; i < dominated.length; i++) {
         visitBasicBlockAndSuccessors(dominated[i]);
@@ skipping 179 matching lines @@
   visitParameterValue(HParameterValue node) => visitInstruction(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitStore(HStore node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
+  visitTry(HTry node) => visitControlFlow(node);
   visitTruncatingDivide(HTruncatingDivide node) => visitBinaryArithmetic(node);
   visitTypeGuard(HTypeGuard node) => visitInstruction(node);
   visitIs(HIs node) => visitInstruction(node);
 }
 
 class HInstructionList {
   HInstruction first = null;
   HInstruction last = null;
 
   bool isEmpty() {
@@ skipping 861 matching lines @@
     }
   }
 
   bool typeEquals(other) => other is HInvokeInterceptor;
   bool dataEquals(HInvokeInterceptor other) {
     return builtinJsName == other.builtinJsName && name == other.name;
   }
 }
 
 class HFieldGet extends HInstruction {
-  Element element;
+  final Element element;
   HFieldGet(Element this.element, HInstruction receiver)
       : super(<HInstruction>[receiver]);
-  HFieldGet.fromActivation() : super(<HInstruction>[]);
+  HFieldGet.fromActivation(Element this.element) : super(<HInstruction>[]);
 
   HInstruction get receiver() => inputs.length == 1 ? inputs[0] : null;
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 }
 
 class HFieldSet extends HInstruction {
-  Element element;
+  final Element element;
   HFieldSet(Element this.element, HInstruction receiver, HInstruction value)
       : super(<HInstruction>[receiver, value]);
-  HFieldSet.fromActivation(HInstruction value) : super(<HInstruction>[value]);
+  HFieldSet.fromActivation(Element this.element, HInstruction value)
+      : super(<HInstruction>[value]);
 
   HInstruction get receiver() => inputs.length == 2 ? inputs[0] : null;
   HInstruction get value() => inputs.length == 2 ? inputs[1] : inputs[0];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn() {
     // TODO(ngeoffray): implement more fine grain side effects.
     setAllSideEffects();
   }
 }
@@ skipping 459 matching lines @@
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
 
 class HGoto extends HControlFlow {
   HGoto() : super(const <HInstruction>[]);
   toString() => 'goto';
   accept(HVisitor visitor) => visitor.visitGoto(this);
 }
 
+class HTry extends HControlFlow {
+  HBasicBlock finallyBlock;
+  HTry() : super(const <HInstruction>[]);
+  toString() => 'try';
+  accept(HVisitor visitor) => visitor.visitTry(this);
+}
+
 class HIf extends HConditionalBranch {
   bool hasElse;
   HIf(HInstruction condition, this.hasElse) : super(<HInstruction>[condition]);
   toString() => 'if';
   accept(HVisitor visitor) => visitor.visitIf(this);
 
   HBasicBlock get thenBlock() {
     assert(block.dominatedBlocks[0] === block.successors[0]);
     return block.successors[0];
   }
@@ skipping 60 matching lines @@
   // Literals have the type they have. It can't be changed.
   bool updateType() => false;
 
   bool hasExpectedType() => true;
 
   bool isLiteralBoolean() => value is bool;
   bool isLiteralNull() => value === null;
   bool isLiteralNumber() => value is num;
   bool isLiteralString() => value is DartString;
   bool typeEquals(other) => other is HLiteral;
-  bool dataEquals(HLiteral other) => value == other.value;
+  bool dataEquals(HLiteral other) {
+    if (isLiteralNumber() && other.isLiteralNumber()) {
+      if (value.isNaN()) return other.value.isNaN();
+    }
+    return value == other.value;
+  }
 }
 
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType computeType() => HType.BOOLEAN;
@@ skipping 390 matching lines @@
 
   HInstruction get expression() => inputs[0];
 
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
 
   toString() => "$expression is $typeExpression";
 }