use == and != to enable handling null/undefined

lib/src/codegen/js_codegen.dart

 // Copyright (c) 2015, 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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 1429 matching lines @@
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
     var left = node.leftOperand;
     var right = node.rightOperand;
     var leftType = rules.getStaticType(left);
     var rightType = rules.getStaticType(right);
 
     var code;
     if (op.type.isEqualityOperator) {
       // If we statically know LHS or RHS is null we can generate a clean check.
-      // We can also do this if the left hand side is a primitive type, because
-      // we know then it doesn't have an overridden.
-      if (_isNull(left) || _isNull(right) || typeIsPrimitiveInJS(leftType)) {
-        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-strict-equality-comparison
-        code = op.type == TokenType.EQ_EQ ? '# === #' : '# !== #';
+      // We can also do this if both sides are the same primitive type.
+      if (_canUsePrimitiveEquality(left, right)) {
+        code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
       } else {
         var bang = op.type == TokenType.BANG_EQ ? '!' : '';
         code = '${bang}dart.equals(#, #)';
       }
       return js.call(code, [_visit(left), _visit(right)]);
     } else if (binaryOperationIsPrimitive(leftType, rightType)) {
       // special cases where we inline the operation
       // these values are assumed to be non-null (determined by the checker)
       // TODO(jmesserly): it would be nice to just inline the method from core,
       // instead of special cases here.
@@ skipping 28 matching lines @@
           _visit(left),
           _visit(right)
         ]);
       } else {
         // Generic static-dispatch, user-defined operator code path.
         return js.call('#.#(#)', [_visit(left), opString, _visit(right)]);
       }
     }
   }
 
+  /// If the type [t] is [int] or [double], returns [num].
+  /// Otherwise returns [t].
+  DartType _canonicalizeNumTypes(DartType t) {
+    var numType = rules.provider.numType;
+    if (t is InterfaceType && t.superclass == numType) return numType;
+    return t;
+  }
+
+  bool _canUsePrimitiveEquality(Expression left, Expression right) {
+    if (_isNull(left) || _isNull(right)) return true;
+
+    var leftType = _canonicalizeNumTypes(rules.getStaticType(left));
+    var rightType = _canonicalizeNumTypes(rules.getStaticType(right));
+    return _isJSBuiltinType(leftType) && leftType == rightType;
+  }
+
   bool _isNull(Expression expr) => expr is NullLiteral;
 
   // TODO(jmesserly, vsm): Refactor this logic.
   SimpleIdentifier _createTemporary(String name, DartType type) {
     // We use an invalid source location to signal that this is a temporary.
     // See [_isTemporary].
     // TODO(jmesserly): alternatives are
     // * (ab)use Element.isSynthetic, which isn't currently used for
     //   LocalVariableElementImpl, so we could repurpose to mean "temp".
     // * add a new property to LocalVariableElementImpl.
@@ skipping 840 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }