more housecleaning: helpers on rules

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 73 matching lines @@
   final _temps = new HashMap<Element, JS.TemporaryId>();
   final _qualifiedIds = new List<Tuple2<Element, JS.MaybeQualifiedId>>();
 
   /// The name for the library's exports inside itself.
   /// `exports` was chosen as the most similar to ES module patterns.
   final _dartxVar = new JS.Identifier('dartx');
   final _exportsVar = new JS.TemporaryId('exports');
   final _runtimeLibVar = new JS.Identifier('dart');
   final _namedArgTemp = new JS.TemporaryId('opts');
 
+  final TypeProvider _types;
+
   ConstFieldVisitor _constField;
 
   ModuleItemLoadOrder _loader;
 
   /// _interceptors.JSArray<E>, used for List literals.
   ClassElement _jsArray;
 
   /// The default value of the module object. See [visitLibraryDirective].
   String _jsModuleValue;
 
   Map<String, DartType> _objectMembers;
 
   JSCodegenVisitor(AbstractCompiler compiler, this.currentLibrary,
       this._extensionTypes, this._fieldsNeedingStorage)
       : compiler = compiler,
         options = compiler.options.codegenOptions,
-        rules = compiler.rules {
+        rules = compiler.rules,
+        _types = compiler.context.typeProvider {
     _loader = new ModuleItemLoadOrder(_emitModuleItem);
 
     var context = compiler.context;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
     _jsArray = interceptors.getType('JSArray');
 
     _objectMembers = getObjectMemberMap(types);
   }
 
@@ skipping 188 matching lines @@
   visitAsExpression(AsExpression node) {
     var from = getStaticType(node.expression);
     var to = node.type.type;
 
     var fromExpr = _visit(node.expression);
 
     // Skip the cast if it's not needed.
     if (rules.isSubTypeOf(from, to)) return fromExpr;
 
     // All Dart number types map to a JS double.
-    if (rules.isNumberInJS(from) && rules.isNumberInJS(to)) {
+    if (_isNumberInJS(from) && _isNumberInJS(to)) {
       // Make sure to check when converting to int.
-      if (!rules.isIntType(from) && rules.isIntType(to)) {
+      if (from != _types.intType && to == _types.intType) {
         return js.call('dart.asInt(#)', [fromExpr]);
       }
 
       if (!rules.isNonNullableType(from) && rules.isNonNullableType(to)) {
         // Converting from a nullable number to a non-nullable number
         // only requires a null check.
         // TODO(jmesserly): a lot of these checks are meaningless, as people use
         // `num` to mean "any kind of number" rather than "could be null".
         // The core libraries especially suffer from this problem, with many of
         // the `num` methods returning `num`.
@@ skipping 21 matching lines @@
       result = js.call('dart.is(#, #)', [lhs, _emitTypeName(type)]);
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
     }
     return result;
   }
 
   String _jsTypeofName(DartType t) {
-    if (rules.isNumberInJS(t)) return 'number';
-    if (rules.isStringType(t)) return 'string';
-    if (rules.isBoolType(t)) return 'boolean';
+    if (_isNumberInJS(t)) return 'number';
+    if (t == _types.stringType) return 'string';
+    if (t == _types.boolType) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     var element = node.element;
     var type = element.type;
     var name = element.name;
 
     var fnType = annotateTypeDef(
@@ skipping 1784 matching lines @@
     var type = constructor.type.type;
     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 _isJSBuiltinType(DartType t) =>
-      typeIsPrimitiveInJS(t) || rules.isStringType(t);
+      typeIsPrimitiveInJS(t) || t == _types.stringType;
 
   bool typeIsPrimitiveInJS(DartType t) =>
-      rules.isNumberInJS(t) || rules.isBoolType(t);
+      _isNumberInJS(t) || t == _types.boolType;
 
   bool typeIsNonNullablePrimitiveInJS(DartType t) =>
       typeIsPrimitiveInJS(t) && rules.isNonNullableType(t);
 
   bool binaryOperationIsPrimitive(DartType leftT, DartType rightT) =>
       typeIsPrimitiveInJS(leftT) && typeIsPrimitiveInJS(rightT);
 
   bool unaryOperationIsPrimitive(DartType t) => typeIsPrimitiveInJS(t);
 
   bool _isNonNullableExpression(Expression expr) {
@@ skipping 103 matching lines @@
 
       var vars = <String, 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) ||
-        rules.isStringType(leftType) && op.type == TokenType.PLUS) {
+        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.
       if (op.type == TokenType.TILDE_SLASH) {
         // `a ~/ b` is equivalent to `(a / b).truncate()`
         var div = AstBuilder.binaryExpression(left, '/', right)
           ..staticType = node.staticType;
         return _emitSend(div, 'truncate', []);
       } else {
@@ skipping 937 matching lines @@
 
   JS.Node annotateVariable(JS.Node node, VariableElement e) =>
       options.closure && e != null
           ? node.withClosureAnnotation(closureAnnotationForVariable(e))
           : node;
 
   JS.Node annotateTypeDef(JS.Node node, FunctionTypeAliasElement e) =>
       options.closure && e != null
           ? node.withClosureAnnotation(closureAnnotationForTypeDef(e))
           : node;
+
+  /// 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);
 }
 
 class JSGenerator extends CodeGenerator {
   final _extensionTypes = new HashSet<ClassElement>();
 
   JSGenerator(AbstractCompiler compiler) : super(compiler) {
     // TODO(jacobr): determine the the set of types with extension methods from
     // the annotations rather than hard coding the list once the analyzer
     // supports summaries.
     var context = compiler.context;
@@ skipping 57 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }