dart2js: Keep refined type for type checks

pkg/compiler/lib/src/ssa/codegen.dart

 // Copyright (c) 2012, 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:math' as math;
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
@@ skipping 2789 matching lines @@
   }
 
   void emitIsViaInterceptor(
       HIsViaInterceptor node, SourceInformation sourceInformation,
       {bool negative: false}) {
     checkTypeViaProperty(
         node.interceptor, node.typeExpression, sourceInformation,
         negative: negative);
   }
 
-  js.Expression generateReceiverOrArgumentTypeTest(
-      HInstruction input, TypeMask checkedType) {
-    TypeMask inputType = input.instructionType;
+  js.Expression generateReceiverOrArgumentTypeTest(HTypeConversion node) {
+    HInstruction input = node.checkedInput;
+    TypeMask inputType = node.inputType ?? input.instructionType;
+    TypeMask checkedType = node.checkedType;
     // Figure out if it is beneficial to turn this into a null check.
     // V8 generally prefers 'typeof' checks, but for integers and
     // indexable primitives we cannot compile this test into a single
     // typeof check so the null check is cheaper.
     bool isIntCheck = checkedType.containsOnlyInt(closedWorld);
-    bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(closedWorld);
+    bool turnIntoNumCheck =
+        isIntCheck && inputType.nonNullable().containsOnlyInt(closedWorld);

[Siggi Cherem (dart-lang), 2017/02/03 21:48:16]

I think it's fine to keep it nullable here (the answer is the same I believe)

     bool turnIntoNullCheck = !turnIntoNumCheck &&
         (checkedType.nullable() == inputType) &&
         (isIntCheck ||
             checkedType.satisfies(helpers.jsIndexableClass, closedWorld));
 
     if (turnIntoNullCheck) {
       use(input);
       return new js.Binary("==", pop(), new js.LiteralNull())
           .withSourceInformation(input.sourceInformation);
     } else if (isIntCheck && !turnIntoNumCheck) {
@@ skipping 12 matching lines @@
       // input is !string
       checkString(input, '!==', input.sourceInformation);
       return pop();
     }
     reporter.internalError(input, 'Unexpected check: $checkedType.');
     return null;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
-      js.Expression test = generateReceiverOrArgumentTypeTest(
-          node.checkedInput, node.checkedType);
+      js.Expression test = generateReceiverOrArgumentTypeTest(node);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
         generateThrowWithHelper(
             helpers.throwIllegalArgumentException, node.checkedInput,
             sourceInformation: node.sourceInformation);
       } else if (node.isReceiverTypeCheck) {
         use(node.checkedInput);
         js.Name methodName =
@@ skipping 251 matching lines @@
     registry.registerStaticUse(new StaticUse.staticInvoke(
         helper, new CallStructure.unnamed(argumentCount)));
     return backend.emitter.staticFunctionAccess(helper);
   }
 
   @override
   void visitRef(HRef node) {
     visit(node.value);
   }
 }