Separate HTypeConversion checked type from output type.

sdk/lib/_internal/compiler/implementation/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 2451 matching lines @@
         js.Expression objectTest = pop();
         checkType(input, interceptor, type, negative: negative);
         push(new js.Binary(negative ? '||' : '&&', objectTest, pop()), node);
       } else {
         checkType(input, interceptor, type, negative: negative);
         attachLocationToLast(node);
       }
     }
   }
 
-  js.Expression generateTest(HCheck node) {
-    HInstruction input = node.checkedInput;
+  js.Expression generateTest(HInstruction input, HType checkedType) {
     TypeMask receiver = input.instructionType.computeMask(compiler);
-    TypeMask mask = node.instructionType.computeMask(compiler);
+    TypeMask mask = checkedType.computeMask(compiler);
     // 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() && node.isInteger();
+    bool turnIntoNumCheck = input.isIntegerOrNull() && checkedType.isInteger();
     bool turnIntoNullCheck = !turnIntoNumCheck
         && (mask.nullable() == receiver)
-        && (node.isInteger() || node.isIndexablePrimitive(compiler));
+        && (checkedType.isInteger() || checkedType.isIndexablePrimitive(compiler));

[ngeoffray, 2013/10/24 06:50:55]

Line too long.

[sra1, 2013/10/25 03:48:53]

Done.

     js.Expression test;
     if (turnIntoNullCheck) {
       use(input);
       test = new js.Binary("==", pop(), new js.LiteralNull());
-    } else if (node.isInteger() && !turnIntoNumCheck) {
+    } else if (checkedType.isInteger() && !turnIntoNumCheck) {
       // input is !int
       checkInt(input, '!==');
       test = pop();
-    } else if (node.isNumber() || turnIntoNumCheck) {
+    } else if (checkedType.isNumber() || turnIntoNumCheck) {
       // input is !num
       checkNum(input, '!==');
       test = pop();
-    } else if (node.isBoolean()) {
+    } else if (checkedType.isBoolean()) {
       // input is !bool
       checkBool(input, '!==');
       test = pop();
-    } else if (node.isString(compiler)) {
+    } else if (checkedType.isString(compiler)) {
       // input is !string
       checkString(input, '!==');
       test = pop();
-    } else if (node.isExtendableArray(compiler)) {
+    } else if (checkedType.isExtendableArray(compiler)) {
       // 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 (node.isMutableArray(compiler)) {
+    } else if (checkedType.isMutableArray(compiler)) {
       // 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 (node.isReadableArray(compiler)) {
+    } else if (checkedType.isReadableArray(compiler)) {
       // 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 (node.isIndexablePrimitive(compiler)) {
+    } else if (checkedType.isIndexablePrimitive(compiler)) {
       // 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('Unexpected check', instruction: input);
     }
     return test;
   }
 
   void visitTypeConversion(HTypeConversion node) {
     if (node.isArgumentTypeCheck || node.isReceiverTypeCheck) {
       // An int check if the input is not int or null, is not
       // sufficient for doing a argument or receiver check.
-      assert(!node.isInteger() || node.checkedInput.isIntegerOrNull());
-      js.Expression test = generateTest(node);
+      assert(!node.checkedType.isInteger() ||
+          node.checkedInput.isIntegerOrNull());
+      js.Expression test = generateTest(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 = jsPropertyCall(pop(), methodName, []);
@@ skipping 79 matching lines @@
       bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(method));
     }
     js.Call call = new js.Call(bailoutTarget, arguments);
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   // Generate a type guard, something like "if (typeof t0 == 'number')" and the
   // corresponding bailout call, something like "return $.foo$bailout(t0, t1);"
   void visitTypeGuard(HTypeGuard node) {
-    js.Expression test = generateTest(node);
+    js.Expression test = generateTest(node.checkedInput, node.instructionType);
     pushStatement(new js.If.noElse(test, bailout(node)), node);
   }
 
   void visitBailoutTarget(HBailoutTarget target) {
     // Do nothing. Bailout targets are only used in the non-optimized version.
   }
 
   void preLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
   }
 
@@ skipping 373 matching lines @@
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive(compiler) && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }