fix some errors in our SDK, mostly around numbers

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 293 matching lines @@
     return 'Symbol';
   }
 
   bool isPublic(String name) => !name.startsWith('_');
 
   @override
   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 _visit(node.expression);
+    if (rules.isSubTypeOf(from, to)) return fromExpr;
 
     // All Dart number types map to a JS double.
-    if (rules.isNumType(from) &&
-        (rules.isIntType(to) || rules.isDoubleType(to))) {
-      // 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`.
+    if (rules.isNumberInJS(from) && rules.isNumberInJS(to)) {
+      // Make sure to check when converting to int.
+      if (!rules.isIntType(from) && rules.isIntType(to)) {
+        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.
-        return js.call('dart.notNull(#)', _visit(node.expression));
+        // 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`.
+        return js.call('dart.notNull(#)', fromExpr);
       } else {
         // A no-op in JavaScript.
-        return _visit(node.expression);
+        return fromExpr;
       }
     }
 
-    return _emitCast(node.expression, to);
+    return js.call('dart.as(#, #)', [fromExpr, _emitTypeName(to)]);
   }
 
-  _emitCast(Expression node, DartType type) => js.call('dart.as(#)', [
-        [_visit(node), _emitTypeName(type)]
-      ]);
-
   @override
   visitIsExpression(IsExpression node) {
     // Generate `is` as `dart.is` or `typeof` depending on the RHS type.
     JS.Expression result;
     var type = node.type.type;
     var lhs = _visit(node.expression);
     var typeofName = _jsTypeofName(type);
     if (typeofName != null) {
       result = js.call('typeof # == #', [lhs, js.string(typeofName, "'")]);
     } else {
       // Always go through a runtime helper, because implicit interfaces.
       result = js.call('dart.is(#, #)', [lhs, _emitTypeName(type)]);
     }
 
     if (node.notOperator != null) {
       return js.call('!#', result);
     }
     return result;
   }
 
   String _jsTypeofName(DartType t) {
-    if (rules.isIntType(t) || rules.isDoubleType(t)) return 'number';
+    if (rules.isNumberInJS(t)) return 'number';
     if (rules.isStringType(t)) return 'string';
     if (rules.isBoolType(t)) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
     var element = node.element;
     var type = element.type;
     var name = element.name;
@@ skipping 1786 matching lines @@
         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);
 
-  bool typeIsPrimitiveInJS(DartType t) => rules.isIntType(t) ||
-      rules.isDoubleType(t) ||
-      rules.isBoolType(t) ||
-      rules.isNumType(t);
+  bool typeIsPrimitiveInJS(DartType t) =>
+      rules.isNumberInJS(t) || rules.isBoolType(t);
 
   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 1073 matching lines @@
 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;
     var src = context.sourceFactory.forUri('dart:_interceptors');
     var interceptors = context.computeLibraryElement(src);
-    for (var t in ['JSArray', 'JSString', 'JSInt', 'JSDouble', 'JSBool']) {
+    for (var t in ['JSArray', 'JSString', 'JSNumber', 'JSBool']) {
       _addExtensionType(interceptors.getType(t).type);
     }
+    // TODO(jmesserly): manually add `int` and `double`
+    // Unfortunately our current analyzer rejects "implements int".
+    // Fix was landed, so we can remove this hack once we're updated:
+    // https://github.com/dart-lang/sdk/commit/d7cd11f86a02f55269fc8d9843e7758ebeeb81c8
+    _addExtensionType(context.typeProvider.intType);
+    _addExtensionType(context.typeProvider.doubleType);
   }
 
   void _addExtensionType(InterfaceType t) {
     if (t.isObject || !_extensionTypes.add(t.element)) return;
     t = fillDynamicTypeArgs(t, rules.provider) as InterfaceType;
     t.interfaces.forEach(_addExtensionType);
     t.mixins.forEach(_addExtensionType);
     _addExtensionType(t.superclass);
   }
 
@@ skipping 36 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);
 }