Generate better code for '=='.

pkg/dev_compiler/lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 28 matching lines @@
 import '../js_ast/js_ast.dart' as JS;
 import '../js_ast/js_ast.dart' show js;
 import 'ast_builder.dart' show AstBuilder;
 import 'compiler.dart' show BuildUnit, CompilerOptions, JSModuleFile;
 import 'element_helpers.dart';
 import 'extension_types.dart' show ExtensionTypeSet;
 import 'js_interop.dart';
 import 'js_metalet.dart' as JS;
 import 'js_names.dart' as JS;
 import 'js_typeref_codegen.dart' show JsTypeRefCodegen;
+import 'js_typerep.dart' show JSTypeRep;
 import 'module_builder.dart' show pathToJSIdentifier;
 import 'nullable_type_inference.dart' show NullableTypeInference;
 import 'property_model.dart';
 import 'reify_coercions.dart' show CoercionReifier;
 import 'side_effect_analysis.dart' show ConstFieldVisitor, isStateless;
 import 'type_utilities.dart';
 
 /// The code generator for Dart Dev Compiler.
 ///
 /// Takes as input resolved Dart ASTs for every compilation unit in every
 /// library in the module. Produces a single JavaScript AST for the module as
-/// output, along with its source map.
+// output, along with its source map.
 ///
 /// This class attempts to preserve identifier names and structure of the input
 /// Dart code, whenever this is possible to do in the generated code.
 //
 // TODO(jmesserly): we should use separate visitors for statements and
 // expressions. Declarations are handled directly, and many minor component
 // AST nodes aren't visited, so the visitor pattern isn't helping except for
 // expressions (which result in JS.Expression) and statements
 // (which result in (JS.Statement).
 class CodeGenerator extends Object
     with ClosureAnnotator, JsTypeRefCodegen, NullableTypeInference
     implements AstVisitor<JS.Node> {
   final AnalysisContext context;
   final SummaryDataStore summaryData;
 
   final CompilerOptions options;
   final StrongTypeSystemImpl rules;
+  JSTypeRep typeRep;
 
   /// The set of libraries we are currently compiling, and the temporaries used
   /// to refer to them.
   ///
   /// We sometimes special case codegen for a single library, as it simplifies
   /// name scoping requirements.
   final _libraries = new Map<LibraryElement, JS.Identifier>();
 
   /// Imported libraries, and the temporaries used to refer to them.
   final _imports = new Map<LibraryElement, JS.TemporaryId>();
@@ skipping 110 matching lines @@
         _asyncStreamIterator =
             _getLibrary(c, 'dart:async').getType('StreamIterator').type,
         _jsArray = _getLibrary(c, 'dart:_interceptors').getType('JSArray'),
         interceptorClass =
             _getLibrary(c, 'dart:_interceptors').getType('Interceptor'),
         dartCoreLibrary = _getLibrary(c, 'dart:core'),
         boolClass = _getLibrary(c, 'dart:core').getType('bool'),
         intClass = _getLibrary(c, 'dart:core').getType('int'),
         numClass = _getLibrary(c, 'dart:core').getType('num'),
         nullClass = _getLibrary(c, 'dart:core').getType('Null'),
         objectClass = _getLibrary(c, 'dart:core').getType('Object'),

[Jennifer Messerly, 2017/06/26 22:42:57]

we may want to grab the FunctionElement for `identical` based on a few
suggestions below. That can be done with:

final FunctionElement _coreIdentical;

...

    _coreIdentical = _getLibrary(c,
'dart:core').publicNamespace.get('identical'),

[Leaf, 2017/06/30 21:55:31]

Done.

         stringClass = _getLibrary(c, 'dart:core').getType('String'),
         functionClass = _getLibrary(c, 'dart:core').getType('Function'),
         privateSymbolClass =
             _getLibrary(c, 'dart:_internal').getType('PrivateSymbol'),
-        dartJSLibrary = _getLibrary(c, 'dart:js');
+        dartJSLibrary = _getLibrary(c, 'dart:js') {
+    typeRep = new JSTypeRep(rules, types);
+  }
 
   Element get currentElement => _currentElements.last;
 
   LibraryElement get currentLibrary => currentElement.library;
 
   /// The main entry point to JavaScript code generation.
   ///
   /// Takes the metadata for the build unit, as well as resolved trees and
   /// errors, and computes the output module code and optionally the source map.
   JSModuleFile compile(BuildUnit unit, List<CompilationUnit> compilationUnits,
@@ skipping 467 matching lines @@
     Expression fromExpr = node.expression;
     var from = getStaticType(fromExpr);
     var to = node.type.type;
 
     JS.Expression jsFrom = _visit(fromExpr);
 
     // Skip the cast if it's not needed.
     if (rules.isSubtypeOf(from, to)) return jsFrom;
 
     // All Dart number types map to a JS double.
-    if (_isNumberInJS(from) && _isNumberInJS(to)) {
+    if (typeRep.isNumber(from) && typeRep.isNumber(to)) {
       // Make sure to check when converting to int.
       if (from != types.intType && to == types.intType) {
         // TODO(jmesserly): fuse this with notNull check.
         return _callHelper('asInt(#)', jsFrom);
       }
 
       // A no-op in JavaScript.
       return jsFrom;
     }
 
@@ skipping 27 matching lines @@
       result = js.call('#.is(#)', [castType, lhs]);
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
     }
     return result;
   }
 
   String _jsTypeofName(DartType t) {
-    if (_isNumberInJS(t)) return 'number';
+    if (typeRep.isNumber(t)) return 'number';
     if (t == types.stringType) return 'string';
     if (t == types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) => _emitTypedef(node);
 
   @override
   visitGenericTypeAlias(GenericTypeAlias node) => _emitTypedef(node);
@@ skipping 2752 matching lines @@
       InvocationExpression node, JS.Expression fn, List<JS.Expression> args) {
     var typeArgs = _emitInvokeTypeArguments(node);
     if (typeArgs != null) {
       return _callHelper(
           'dgcall(#, #, #)', [fn, new JS.ArrayInitializer(typeArgs), args]);
     } else {
       return _callHelper('dcall(#, #)', [fn, args]);
     }
   }
 
+  bool _doubleEqIsIdentity(Expression left, Expression right, DartType leftType,
+      DartType rightType) {

[Jennifer Messerly, 2017/06/26 22:42:58]

personally I'd refactor this: remove leftType and rightType, use left.staticType
and right.staticType.

Less parameters simplifies things :)

I'm 99% sure getStaticType is an old obsolete workaround for an analyzer bug.
I'll see if I can get a CL to remove it. worst case, feel free to call
`getStaticType(left)` and `getStaticType(right)` below

Also: do we need to canonicalize the numeric type?

[Leaf, 2017/06/30 21:55:32]

Done.
No, handled by equalityMayConvert. 

+    // If we statically know LHS or RHS is null we can use ==.
+    if (_isNull(left) || _isNull(right)) return true;
+    // If the representation of the  two types will not induce conversion in
+    // JS then we can use == .
+    if (!typeRep.equalityMayConvert(leftType, rightType)) return true;

[Jennifer Messerly, 2017/06/26 22:42:57]

this can be simplified too:

return !typeRep.equalityMayConvert(leftType, rightType);

[Leaf, 2017/06/30 21:55:31]

Doh.  How embarrassing, I hate code like this.  

+    return false;
+  }
+
+  bool _tripleEqIsIdentity(Expression left, Expression right, DartType leftType,
+      DartType rightType) {

[Jennifer Messerly, 2017/06/26 22:42:57]

leftType and rightType are unused

[Leaf, 2017/06/30 21:55:32]

Done.

+    // If either is non-nullable, then we don't need to worry about
+    // equating null and undefined, and so we can use triple equals.
+    if (!isNullable(left) || !isNullable(right)) return true;

[Jennifer Messerly, 2017/06/26 22:42:58]

return !isNullable(left) || !isNullable(right);

[Leaf, 2017/06/30 21:55:32]

Aargh!  Strong No Hire! 

+    return false;
+  }
+
+  bool _isCoreIdentical(Expression function) {
+    if (function is Identifier) {

[Jennifer Messerly, 2017/06/26 22:42:57]

based on suggestion above, this can be just:

    return function is Identifier && function.staticElement == _coreIdentical;

(I'd be tempted to name the parameter "node" to save a few chars)

[Leaf, 2017/06/30 21:55:31]

Done.

+      var element = function.staticElement;
+      var name = element?.name;
+      var inCore = element?.library?.isDartCore;
+      return name == "identical" && inCore == true;
+    }
+    return false;
+  }
+
+  JS.Expression _emitCoreIdenticalCall(
+      InvocationExpression node, JS.Expression fn, List<JS.Expression> args) {

[Jennifer Messerly, 2017/06/26 22:42:58]

based on suggestions below, the "fn" parameter can be removed

[Leaf, 2017/06/30 21:55:32]

Done.

+    if (args.length != 2) return new JS.Call(fn, args);

[Jennifer Messerly, 2017/06/26 22:42:58]

this can only come up with unsafe flags. I think we could just emit a throw like
we do now in other locations:

  return _callHelper(
    'throw(Error("compile error: calls to `identical` require 2 args")');

[Leaf, 2017/06/30 21:55:31]

Done.

+    var left = node.argumentList.arguments[0];
+    var right = node.argumentList.arguments[1];
+    var leftType = getStaticType(left);
+    var rightType = getStaticType(right);

[Jennifer Messerly, 2017/06/26 22:42:58]

these two lines will go away based on suggestions above

[Leaf, 2017/06/30 21:55:32]

Done.

+    if (_tripleEqIsIdentity(left, right, leftType, rightType)) {
+      return js.call('# === #', args);

[Jennifer Messerly, 2017/06/26 22:42:58]

should we also optimize `!identical(left, right)` ?

(discussed further below in the equality case)

[Leaf, 2017/06/30 21:55:31]

It's a bit awkward to code up (at first glance, I'd have to put a peephole
optimization in _visitTest to see if the thing being negated is core.identical),
and I'd be very surprised if it made any noticeable performance difference.  V8
should be able to do this optimization itself if it cares.  

I guess maybe generating a core.notIdentical call could be a win, but overall
I'm inclined to leave it for now.  Left a TODO.

+    }
+    if (_doubleEqIsIdentity(left, right, leftType, rightType)) {
+      return js.call('# == #', args);
+    }
+    return new JS.Call(fn, args);

[Jennifer Messerly, 2017/06/26 22:42:58]

once we have _coreIdentical, it's possible to just:

return new JS.Call(_emitTopLevelName(_coreIdentical), args);

[Leaf, 2017/06/30 21:55:31]

Done.

+  }
+
   /// Emits a function call, to a top-level function, local function, or
   /// an expression.
   JS.Expression _emitFunctionCall(InvocationExpression node,
       [Expression function]) {
     if (function == null) {
       function = node.function;
     }
     var fn = _visit(function);
     var args = _emitArgumentList(node.argumentList);
     if (isDynamicInvoke(function)) {
       return _emitDynamicInvoke(node, fn, args);
+    } else if (_isCoreIdentical(function)) {
+      return _emitCoreIdenticalCall(node, fn, args);
     } else {
       return new JS.Call(_applyInvokeTypeArguments(fn, node), args);
     }
   }
 
   JS.Expression _applyInvokeTypeArguments(
       JS.Expression target, InvocationExpression node) {
     var typeArgs = _emitInvokeTypeArguments(node);
     if (typeArgs == null) return target;
     return new JS.Call(target, typeArgs);
@@ skipping 529 matching lines @@
         return stringValue != null
             ? js.escapedString(stringValue)
             : new JS.LiteralNull();
       }
       throw new StateError('failed to evaluate $node');
     }
     return _emitInstanceCreationExpression(
         element, type, name, node.argumentList, node.isConst);
   }
 
-  /// True if this type is built-in to JS, and we use the values unwrapped.
-  /// For these types we generate a calling convention via static
-  /// "extension methods". This allows types to be extended without adding
-  /// extensions directly on the prototype.
-  bool isPrimitiveType(DartType t) =>
-      typeIsPrimitiveInJS(t) || t == types.stringType;
-
-  bool typeIsPrimitiveInJS(DartType t) =>
-      _isNumberInJS(t) || t == types.boolType;
-
-  bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
-      typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
-
-  bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
+  bool isPrimitiveType(DartType t) => typeRep.isPrimitive(t);
 
   JS.Expression notNull(Expression expr) {
     if (expr == null) return null;
     var jsExpr = _visit(expr);
     if (!isNullable(expr)) return jsExpr;
     return _callHelper('notNull(#)', jsExpr);
   }
 
+  JS.Expression _emitEqualityOperator(BinaryExpression node, Token op) {
+    var left = node.leftOperand;
+    var right = node.rightOperand;
+
+    JS.Expression doOperator(String eq, String neq) {
+      var code = op.type == TokenType.EQ_EQ ? '# $eq #' : '# $neq #';
+      return js.call(code, [_visit(left), _visit(right)]);
+    }
+
+    JS.Expression doubleEq() => doOperator('==', '!=');
+    JS.Expression tripleEq() => doOperator('===', '!==');
+
+    // All number types are the same to us.
+    var leftType = typeRep.canonicalizeNumTypes(getStaticType(left));
+    var rightType = typeRep.canonicalizeNumTypes(getStaticType(right));
+
+    // If either is null, we can use simple equality.
+    // We need to equate null and undefined, so if both are nullable
+    //  (but not known to be null), we cannot directly use JS ==
+    //  unless we know that conversion will not happen.
+    // Functions may or may not have an [dartx[`==`]] method attached.
+    //   - If they are tearoffs they will, otherwise they won't and equality is
+    // identity.
+    //
+
+    // If we statically know LHS or RHS is null we can use ==.
+    if (_isNull(left) || _isNull(right)) return doubleEq();
+
+    if (left is SuperExpression) {
+      return _emitSend(left, op.lexeme, [right]);
+    }
+
+    // Equality on enums and primitives is identity.
+    // TODO(leafp): Walk the class hierarchy and check to see if == was
+    // overridden
+    var isEnum = leftType is InterfaceType && leftType.element.isEnum;
+    var usesIdentity = typeRep.isPrimitive(leftType) || isEnum;
+
+    // If we know that the left type uses identity for equality, we can
+    // sometimes emit better code.
+    if (usesIdentity) {
+      if (_tripleEqIsIdentity(left, right, leftType, rightType)) {

[Jennifer Messerly, 2017/06/26 22:42:57]

it would be really great if this could reuse _emitCoreIdentical.

I think it's possible to factor it so that works. It'll need negation support,
and removing the JS.Expression for "core.identical" (suggested above). But it'd
be nice to share the logic otherwise. You wouldn't necessarily need the separate
functions for _tripleEqIsIdentity/_doubleEqIsIdentity at that point (tho I think
they'd be fine to keep)

[Leaf, 2017/06/30 21:55:31]

Done.  It changes the generated code a little bit: we generate core.identical
for equality when we know that equality is identity, but we don't know that we
can use triple or double eq.  But that's probably reasonable.

+        return tripleEq();
+      }
+      if (_doubleEqIsIdentity(left, right, leftType, rightType)) {
+        return doubleEq();
+      }
+    }
+
+    var bang = op.type == TokenType.BANG_EQ ? '!' : '';
+
+    if (typeRep.objectMethodsOnPrototype(leftType)) {

[Jennifer Messerly, 2017/06/26 22:42:58]

It looks like you're trying to make sure there's an explicit "==" to call, and
that it's fast to call. That's an impl detail of CodeGenerator and of DDC's core
library/runtime.

Currently == is guaranteed for Dart class types (that aren't JS interop types).
We could put it on JS primitives but that would be slow, so we didn't. We could
add it to functions if we wanted.

// We can call == directly on non-null Dart classes that are
// not JS primitives or interop types.
if (leftType is InterfaceType &&
    !_isJSNative(leftType.element) &&
    typeRep.jsObject(leftType) && 
    !isNullable(left) {
  // ...
}


... the reason I'm putting this suggestion here, is that these details are
specific to `==`, rather than being something about JS Objects or even about all
Dart Object members. (so I think we can remove objectMethodsOnPrototype)

[Leaf, 2017/06/30 21:55:31]

Done.

+      // If left is not nullable, then we don't need to worry about
+      // null/undefined.
+      // TODO(leafp): consider using (left || dart.EQ)['=='](right))
+      // when left is nullable but not falsey
+      if (!isNullable(left)) {
+        var name = _emitMemberName('==', type: leftType);
+        var code = '${bang}#[#](#)';
+        return js.call(code, [_visit(left), name, _visit(right)]);
+      }
+    }
+    // Fall back to equality for now.
+    {

[Jennifer Messerly, 2017/06/26 22:42:58]

is this block needed?

[Leaf, 2017/06/30 21:55:32]

Probably not.  I prefer limiting the scope of local variables with blocks, but
that's probably idiosyncratic in Dart.  Removed.

+      var code = '${bang}#.equals(#, #)';
+      return js.call(code, [_runtimeModule, _visit(left), _visit(right)]);
+    }
+  }
+
   @override
   JS.Expression visitBinaryExpression(BinaryExpression node) {
     var op = node.operator;
 
     // The operands of logical boolean operators are subject to boolean
     // conversion.
     if (op.type == TokenType.BAR_BAR ||
         op.type == TokenType.AMPERSAND_AMPERSAND) {
       return _visitTest(node);
     }
 
+    if (op.type.isEqualityOperator) return _emitEqualityOperator(node, op);
+
     var left = node.leftOperand;
     var right = node.rightOperand;
 
-    var leftType = getStaticType(left);
-    var rightType = 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 both sides are the same primitive type.
-      if (_canUsePrimitiveEquality(left, right)) {
-        code = op.type == TokenType.EQ_EQ ? '# == #' : '# != #';
-      } else if (left is SuperExpression) {
-        return _emitSend(left, op.lexeme, [right]);
-      } else {
-        var bang = op.type == TokenType.BANG_EQ ? '!' : '';
-        code = '${bang}#.equals(#, #)';
-        return js.call(code, [_runtimeModule, _visit(left), _visit(right)]);
-      }
-      return js.call(code, [_visit(left), _visit(right)]);
-    }
-
     if (op.type.lexeme == '??') {
       // TODO(jmesserly): leave RHS for debugging?
       // This should be a hint or warning for dead code.
       if (!isNullable(left)) return _visit(left);
 
       var vars = <JS.MetaLetVariable, JS.Expression>{};
       // Desugar `l ?? r` as `l != null ? l : r`
       var l = _visit(_bindValue(vars, 'l', left, context: left));
       return new JS.MetaLet(vars, [
         js.call('# != null ? # : #', [l, l, _visit(right)])
       ]);
     }
 
-    if (binaryOperationIsPrimitive(leftType, rightType) ||
+    var leftType = getStaticType(left);
+    var rightType = getStaticType(right);
+
+    if (typeRep.binaryOperationIsPrimitive(leftType, rightType) ||
         leftType == types.stringType && op.type == TokenType.PLUS) {
       // 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.
       JS.Expression binary(String code) {
         return js.call(code, [notNull(left), notNull(right)]);
       }
 
       JS.Expression bitwise(String code) {
@@ skipping 214 matching lines @@
         }
       }
       int value = _asIntInRange(expr, 0, 0x7fffffff);
       if (value != null) return value.bitLength;
       return MAX;
     }
 
     return bitWidth(expr, 0) < 32;
   }
 
-  /// If the type [t] is [int] or [double], or a type parameter
-  /// bounded by [int], [double] or [num] returns [num].
-  /// Otherwise returns [t].
-  DartType _canonicalizeNumTypes(DartType t) {
-    var numType = types.numType;
-    if (rules.isSubtypeOf(t, numType)) return numType;
-    return t;
-  }
-
-  bool _canUsePrimitiveEquality(Expression left, Expression right) {
-    if (_isNull(left) || _isNull(right)) return true;
-
-    var leftType = _canonicalizeNumTypes(getStaticType(left));
-    var rightType = _canonicalizeNumTypes(getStaticType(right));
-    return isPrimitiveType(leftType) && leftType == rightType;
-  }
-
-  bool _isNull(Expression expr) => expr is NullLiteral;
+  bool _isNull(Expression expr) =>
+      expr is NullLiteral || getStaticType(expr).isDartCoreNull;

[Jennifer Messerly, 2017/06/26 22:42:57]

FYI. We may need to also change our nullable analysis to know this.

[Leaf, 2017/06/30 21:55:31]

Acknowledged.

 
   SimpleIdentifier _createTemporary(String name, DartType type,
       {bool nullable: true, JS.Expression variable, bool dynamicInvoke}) {
     // 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.
     // * create a new subtype of LocalVariableElementImpl to mark a temp.
@@ skipping 124 matching lines @@
   ///     (let* (x1=expr1, x2=expr2, t=expr1[expr2]) { x1[x2] = t + 1; t })
   ///
   /// The [JS.MetaLet] nodes automatically simplify themselves if they can.
   /// For example, if the result value is not used, then `t` goes away.
   @override
   JS.Expression visitPostfixExpression(PostfixExpression node) {
     var op = node.operator;
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
-    if (unaryOperationIsPrimitive(dispatchType)) {
+    if (typeRep.unaryOperationIsPrimitive(dispatchType)) {
       if (!isNullable(expr)) {
         return js.call('#$op', _visit(expr));
       }
     }
 
     assert(op.lexeme == '++' || op.lexeme == '--');
 
     // Handle the left hand side, to ensure each of its subexpressions are
     // evaluated only once.
     var vars = <JS.MetaLetVariable, JS.Expression>{};
@@ skipping 16 matching lines @@
   JS.Expression visitPrefixExpression(PrefixExpression node) {
     var op = node.operator;
 
     // Logical negation, `!e`, is a boolean conversion context since it is
     // defined as `e ? false : true`.
     if (op.lexeme == '!') return _visitTest(node);
 
     var expr = node.operand;
 
     var dispatchType = getStaticType(expr);
-    if (unaryOperationIsPrimitive(dispatchType)) {
+    if (typeRep.unaryOperationIsPrimitive(dispatchType)) {
       if (op.lexeme == '~') {
-        if (_isNumberInJS(dispatchType)) {
+        if (typeRep.isNumber(dispatchType)) {
           JS.Expression jsExpr = js.call('~#', notNull(expr));
           return _coerceBitOperationResultToUnsigned(node, jsExpr);
         }
         return _emitSend(expr, op.lexeme[0], []);
       }
       if (!isNullable(expr)) {
         return js.call('$op#', _visit(expr));
       }
       if (op.lexeme == '++' || op.lexeme == '--') {
         // We need a null check, so the increment must be expanded out.
@@ skipping 723 matching lines @@
         return finish(js.call(code,
             [_visitTest(node.leftOperand), _visitTest(node.rightOperand)]));
       }
 
       var op = node.operator.type.lexeme;
       if (op == '&&') return shortCircuit('# && #');
       if (op == '||') return shortCircuit('# || #');
     }
     if (node is AsExpression && CoercionReifier.isImplicitCast(node)) {
       assert(node.staticType == types.boolType);
-      return _callHelper('test(#)', _visit(node.expression));
+      return _callHelper('dtest(#)', _visit(node.expression));
     }
     JS.Expression result = _visit(node);
     if (isNullable(node)) result = _callHelper('test(#)', result);
     return result;
   }
 
   /// Like [_emitMemberName], but for declaration sites.
   ///
   /// Unlike call sites, we always have an element available, so we can use it
   /// directly rather than computing the relevant options for [_emitMemberName].
@@ skipping 182 matching lines @@
   JS.Node/*=T*/ annotate/*<T extends JS.Node>*/(
       JS.Node/*=T*/ node, AstNode original,
       [Element element]) {
     if (options.closure && element != null) {
       node = node.withClosureAnnotation(closureAnnotationFor(
           node, original, element, namedArgumentTemp.name)) as dynamic/*=T*/;
     }
     return node..sourceInformation = original;
   }
 
-  /// Returns true if this is any kind of object represented by `Number` in JS.
-  ///
-  /// In practice, this is 4 types: num, int, double, and JSNumber.
-  ///
-  /// JSNumber is the type that actually "implements" all numbers, hence it's
-  /// a subtype of int and double (and num). It's in our "dart:_interceptors".
-  bool _isNumberInJS(DartType t) =>
-      rules.isSubtypeOf(t, types.numType) &&
-      !rules.isSubtypeOf(t, types.nullType);
-
   /// Return true if this is one of the methods/properties on all Dart Objects
   /// (toString, hashCode, noSuchMethod, runtimeType).
   ///
   /// Operator == is excluded, as it is handled as part of the equality binary
   /// operator.
   bool isObjectMember(String name) {
     // We could look these up on Object, but we have hard coded runtime helpers
     // so it's not really providing any benefit.
     switch (name) {
       case 'hashCode':
@@ skipping 283 matching lines @@
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
   var containingLibrary = resolutionMap
       .elementDeclaredByCompilationUnit(target.root as CompilationUnit)
       .library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }