Implement code generation for === and !==.

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 visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
   R visitBoolify(HBoolify node);
   R visitBoundsCheck(HBoundsCheck node);
   R visitDivide(HDivide node);
   R visitEquals(HEquals node);
   R visitExit(HExit node);
   R visitForeign(HForeign node);
   R visitForeignNew(HForeignNew);
   R visitGoto(HGoto node);
   R visitGreater(HGreater node);
   R visitGreaterEqual(HGreaterEqual node);
+  R visitIdentity(HIdentity node);
   R visitIf(HIf node);
   R visitIndex(HIndex node);
   R visitIndexAssign(HIndexAssign node);
   R visitIntegerCheck(HIntegerCheck node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeInterceptor(HInvokeInterceptor node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitLess(HLess node);
@@ skipping 169 matching lines @@
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
+  visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInvokeStatic(node);
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
@@ skipping 1402 matching lines @@
     }
   }
 
   HType computeType() {
     builtin = computeInputsType().isNumber();
     return HType.BOOLEAN;
   }
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
-    if (input == inputs[0]) return HType.UNKNOWN;
+    if (input == target) return HType.UNKNOWN;
     // For all relational operations exept HEquals, we expect to only
     // get numbers.
     return HType.NUMBER;
   }
 
   // A HRelational goes through the builtin operator or the top level
   // element. Therefore, it always has the expected type.
   bool hasExpectedType() => true;
 
   abstract bool evaluate(num a, num b);
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   bool evaluate(num a, num b) => a == b;
   accept(HVisitor visitor) => visitor.visitEquals(this);
   bool typeEquals(other) => other is HEquals;
   bool dataEquals(HInstruction other) => true;
 
   HType computeDesiredInputType(HInstruction input) {
     // TODO(floitsch): we want the target to be a function.
-    if (input == inputs[0]) return HType.UNKNOWN;
+    if (input == target) return HType.UNKNOWN;
     if (left.isNumber() || right.isNumber()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 }
 
+class HIdentity extends HRelational {
+  HIdentity(HStatic target, HInstruction left, HInstruction right)
+      : super(target, left, right);
+  bool evaluate(num a, num b) => a === b;

[ngeoffray, 2012/01/06 08:10:20]

Should that be really 'num' here?

+  accept(HVisitor visitor) => visitor.visitIdentity(this);
+  bool typeEquals(other) => other is HIdentity;
+  bool dataEquals(HInstruction other) => true;
+
+  HType computeType() {
+    builtin = true;
+    return HType.BOOLEAN;
+  }
+
+  bool hasExpectedType() => true;
+
+  HType computeDesiredInputType(HInstruction input) => HType.UNKNOWN;
+}
+
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   bool evaluate(num a, num b) => a > b;
   accept(HVisitor visitor) => visitor.visitGreater(this);
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
@@ skipping 174 matching lines @@
                    HInstruction first,
                    HInstruction second)
       : super(<HInstruction>[first, second]);
   toString() => operation;
   accept(HVisitor visitor) => visitor.visitLogicalOperator(this);
   HInstruction get left() => inputs[0];
   HInstruction get right() => inputs[1];
   HType computeType() => HType.BOOLEAN;
   bool hasExpectedType() => true;
 }