Fix for issue 21579

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.
 
 part of ssa;
 
 class SsaCodeGeneratorTask extends CompilerTask {
 
   final JavaScriptBackend backend;
 
@@ skipping 2234 matching lines @@
   void checkNull(HInstruction input) {
     use(input);
     push(new js.Binary('==', pop(), new js.LiteralNull()));
   }
 
   void checkNonNull(HInstruction input) {
     use(input);
     push(new js.Binary('!=', pop(), new js.LiteralNull()));
   }
 
-  bool checkIndexingBehavior(HInstruction input, {bool negative: false}) {
-    if (!compiler.resolverWorld.isInstantiated(
-          backend.jsIndexingBehaviorInterface)) {
-      return false;
-    }
-
-    use(input);
-    js.Expression object1 = pop();
-    use(input);
-    js.Expression object2 = pop();
-    push(backend.generateIsJsIndexableCall(object1, object2));
-    if (negative) push(new js.Prefix('!', pop()));
-    return true;
-  }
-
   void checkType(HInstruction input, HInstruction interceptor,
                  DartType type, {bool negative: false}) {
     Element element = type.element;
     if (element == backend.jsArrayClass) {
       checkArray(input, negative ? '!==': '===');
       return;
     } else if (element == backend.jsMutableArrayClass) {
       if (negative) {
         checkImmutableArray(input);
       } else {
@@ skipping 180 matching lines @@
         attachLocationToLast(node);
       }
     }
   }
 
   void emitIsViaInterceptor(HIsViaInterceptor node, bool negative) {
     checkTypeViaProperty(node.interceptor, node.typeExpression, negative);
     attachLocationToLast(node);
   }
 
-  js.Expression generateTest(HInstruction input, TypeMask checkedType) {
+  js.Expression generateReceiverOrArgumentTypeTest(
+      HInstruction input, TypeMask checkedType) {
     ClassWorld classWorld = compiler.world;
-    TypeMask receiver = input.instructionType;
+    TypeMask inputType = input.instructionType;
     // 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 turnIntoNumCheck = input.isIntegerOrNull(compiler)
-        && checkedType.containsOnlyInt(classWorld);
+    bool isIntCheck = checkedType.containsOnlyInt(classWorld);
+    bool turnIntoNumCheck = isIntCheck && input.isIntegerOrNull(compiler);
     bool turnIntoNullCheck = !turnIntoNumCheck
-        && (checkedType.nullable() == receiver)
-        && (checkedType.containsOnlyInt(classWorld)
+        && (checkedType.nullable() == inputType)
+        && (isIntCheck
             || checkedType.satisfies(backend.jsIndexableClass, classWorld));
-    js.Expression test;
+
     if (turnIntoNullCheck) {
       use(input);
-      test = new js.Binary("==", pop(), new js.LiteralNull());
-    } else if (checkedType.containsOnlyInt(classWorld) && !turnIntoNumCheck) {
+      return new js.Binary("==", pop(), new js.LiteralNull());
+    } else if (isIntCheck && !turnIntoNumCheck) {
       // input is !int
-      checkInt(input, '!==');
-      test = pop();
-    } else if (checkedType.containsOnlyNum(classWorld) || turnIntoNumCheck) {
+      checkBigInt(input, '!==');
+      return pop();
+    } else if (turnIntoNumCheck || checkedType.containsOnlyNum(classWorld)) {
       // input is !num
       checkNum(input, '!==');
-      test = pop();
+      return pop();
     } else if (checkedType.containsOnlyBool(classWorld)) {
       // input is !bool
       checkBool(input, '!==');
-      test = pop();
+      return pop();
     } else if (checkedType.containsOnlyString(classWorld)) {
       // input is !string
       checkString(input, '!==');
-      test = pop();
-    } else if (checkedType.satisfies(backend.jsExtendableArrayClass,
-                                     classWorld)) {
-      // input is !Object || input is !Array || input.isFixed
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkFixedArray(input);
-      test = new js.Binary('||', objectTest, arrayTest);
-      test = new js.Binary('||', test, pop());
-    } else if (checkedType.satisfies(backend.jsMutableArrayClass, classWorld)) {
-      // input is !Object
-      // || ((input is !Array || input.isImmutable)
-      //     && input is !JsIndexingBehavior)
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-      checkImmutableArray(input);
-      js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
-
-      js.Binary notIndexing = checkIndexingBehavior(input, negative: true)
-          ? new js.Binary('&&', notArrayOrImmutable, pop())
-          : notArrayOrImmutable;
-      test = new js.Binary('||', objectTest, notIndexing);
-    } else if (checkedType.satisfies(backend.jsArrayClass, classWorld)) {
-      // input is !Object
-      // || (input is !Array && input is !JsIndexingBehavior)
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-
-      js.Expression notIndexing = checkIndexingBehavior(input, negative: true)
-          ? new js.Binary('&&', arrayTest, pop())
-          : arrayTest;
-      test = new js.Binary('||', objectTest, notIndexing);
-    } else if (checkedType.satisfies(backend.jsIndexableClass, classWorld)) {
-      // input is !String
-      // && (input is !Object
-      //     || (input is !Array && input is !JsIndexingBehavior))
-      checkString(input, '!==');
-      js.Expression stringTest = pop();
-      checkObject(input, '!==');
-      js.Expression objectTest = pop();
-      checkArray(input, '!==');
-      js.Expression arrayTest = pop();
-
-      js.Binary notIndexingTest = checkIndexingBehavior(input, negative: true)
-          ? new js.Binary('&&', arrayTest, pop())
-          : arrayTest;
-      js.Binary notObjectOrIndexingTest =
-          new js.Binary('||', objectTest, notIndexingTest);
-      test = new js.Binary('&&', stringTest, notObjectOrIndexingTest);
-    } else {
-      compiler.internalError(input, 'Unexpected check.');
+      return pop();
     }
-    return test;
+    compiler.internalError(input, 'Unexpected check.');
+    return null;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       ClassWorld classWorld = compiler.world;
       // An int check if the input is not int or null, is not
       // sufficient for doing an argument or receiver check.
       assert(compiler.trustTypeAnnotations ||
              !node.checkedType.containsOnlyInt(classWorld) ||
              node.checkedInput.isIntegerOrNull(compiler));
-      js.Expression test = generateTest(node.checkedInput, node.checkedType);
+      js.Expression test = generateReceiverOrArgumentTypeTest(
+          node.checkedInput, node.checkedType);
       js.Block oldContainer = currentContainer;
       js.Statement body = new js.Block.empty();
       currentContainer = body;
       if (node.isArgumentTypeCheck) {
         generateThrowWithHelper('iae', node.checkedInput);
       } else if (node.isReceiverTypeCheck) {
         use(node.checkedInput);
         String methodName =
             backend.namer.invocationName(node.receiverTypeCheckSelector);
         js.Expression call = js.propertyCall(pop(), methodName, []);
@@ skipping 133 matching lines @@
   js.PropertyAccess accessHelper(String name) {
     Element helper = backend.findHelper(name);
     if (helper == null) {
       // For mocked-up tests.
       return js.js('(void 0).$name');
     }
     registry.registerStaticUse(helper);
     return backend.namer.elementAccess(helper);
   }
 }