dart2js cps: Set receiver-nullability in analysis pass.

pkg/compiler/lib/src/cps_ir/type_propagation.dart

 // Copyright (c) 2014, 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 dart2js.cps_ir.type_propagation;
 
 import 'optimizers.dart';
 
 import '../closure.dart' show
     ClosureClassElement, Identifiers;
 import '../common/names.dart' show
@@ skipping 960 matching lines @@
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return false;
         }
         if (!isExtendable) return false;
         Primitive addedItem = getDartArgument(node, 0);
         CpsFragment cps = new CpsFragment(sourceInfo);
         cps.invokeBuiltin(BuiltinMethod.Push,
             list,
-            <Primitive>[addedItem],
-            receiverIsNotNull: listValue.isDefinitelyNotNull);
+            <Primitive>[addedItem]);
         cps.invokeContinuation(cont, [cps.makeNull()]);
         replaceSubtree(node, cps.result);
         push(cps.result);
         return true;
 
       case 'removeLast':
         if (!node.selector.isCall ||
             node.selector.argumentCount != 0) {
           return false;
         }
         if (!isExtendable) return false;
         CpsFragment cps = new CpsFragment(sourceInfo);
         Primitive length = cps.letPrim(new GetLength(list));
         Primitive isEmpty = cps.applyBuiltin(
             BuiltinOperator.StrictEq,
             [length, cps.makeZero()]);
         CpsFragment fail = cps.ifTruthy(isEmpty);
         fail.invokeStaticThrower(
             backend.getThrowIndexOutOfBoundsError(),
             [list, fail.makeConstant(new IntConstantValue(-1))]);
         Primitive removedItem = cps.invokeBuiltin(BuiltinMethod.Pop,
             list,
-            <Primitive>[],
-            receiverIsNotNull: listValue.isDefinitelyNotNull);
+            <Primitive>[]);
         cps.invokeContinuation(cont, [removedItem]);
         replaceSubtree(node, cps.result);
         push(cps.result);
         return true;
 
       case 'addAll':
         if (!node.selector.isCall ||
             node.selector.argumentCount != 1) {
           return false;
         }
         if (!isExtendable) return false;
         Primitive addedList = getDartArgument(node, 0);
         // Rewrite addAll([x1, ..., xN]) to push(x1, ..., xN).
         // Ensure that the list is not mutated between creation and use.
         // We aim for the common case where this is the only use of the list,
         // which also guarantees that this list is not mutated before use.
         if (addedList is! LiteralList || !addedList.hasExactlyOneUse) {
           return false;
         }
         LiteralList addedLiteral = addedList;
         CpsFragment cps = new CpsFragment(sourceInfo);
         cps.invokeBuiltin(BuiltinMethod.Push,
             list,
-            addedLiteral.values.map((ref) => ref.definition).toList(),
-            receiverIsNotNull: listValue.isDefinitelyNotNull);
+            addedLiteral.values.map((ref) => ref.definition).toList());
         cps.invokeContinuation(cont, [cps.makeNull()]);
         replaceSubtree(node, cps.result);
         push(cps.result);
         return true;
 
       case 'elementAt':
         if (!node.selector.isCall ||
             node.selector.positionalArgumentCount != 1 ||
             node.selector.namedArgumentCount != 0) {
           return false;
@@ skipping 427 matching lines @@
   void visitInvokeMethod(InvokeMethod node) {
     if (constifyExpression(node)) return;
     if (specializeOperatorCall(node)) return;
     if (specializeFieldAccess(node)) return;
     if (specializeIndexableAccess(node)) return;
     if (specializeArrayAccess(node)) return;
     if (specializeSingleUseClosureCall(node)) return;
     if (specializeClosureCall(node)) return;
 
     AbstractValue receiver = getValue(node.receiver.definition);
-    node.receiverIsNotNull = receiver.isDefinitelyNotNull;
 
     if (node.receiverIsIntercepted &&
         node.receiver.definition.sameValue(node.arguments[0].definition)) {
       // The receiver and first argument are the same; that means we already
       // determined in visitInterceptor that we are targeting a non-interceptor.
 
       // Check if any of the possible targets depend on the extra receiver
       // argument. Mixins do this, and tear-offs always needs the extra receiver
       // argument because BoundClosure uses it for equality and hash code.
       // TODO(15933): Make automatically generated property extraction
@@ skipping 336 matching lines @@
     if (node.dartType == dartTypes.coreTypes.numType ||
         node.dartType == dartTypes.coreTypes.doubleType) {
       return new ApplyBuiltinOperator(
           BuiltinOperator.IsNumber,
           <Primitive>[prim],
           node.sourceInformation);
     }
     return null;
   }
 
-  void visitGetField(GetField node) {
-    node.objectIsNotNull = getValue(node.object.definition).isDefinitelyNotNull;
-  }
-
-  void visitGetLength(GetLength node) {
-    node.objectIsNotNull = getValue(node.object.definition).isDefinitelyNotNull;
-  }
-
   Primitive visitInterceptor(Interceptor node) {
     AbstractValue value = getValue(node.input.definition);
     // If the exact class of the input is known, replace with a constant
     // or the input itself.
     ClassElement singleClass;
     if (lattice.isDefinitelyInt(value)) {
       // Classes like JSUInt31 and JSUInt32 do not exist at runtime, so ensure
       // all the int classes get mapped tor their runtime class.
       singleClass = backend.jsIntClass;
     } else if (lattice.isDefinitelyNativeList(value)) {
@@ skipping 278 matching lines @@
     // continuation. Note that this is effectively a phi node in SSA terms.
     for (int i = 0; i < node.arguments.length; i++) {
       Primitive def = node.arguments[i].definition;
       AbstractValue cell = getValue(def);
       setValue(cont.parameters[i], cell);
     }
   }
 
   void visitInvokeMethod(InvokeMethod node) {
     AbstractValue receiver = getValue(node.receiver.definition);
+    node.receiverIsNotNull = receiver.isDefinitelyNotNull;
     if (receiver.isNothing) {
       return;  // And come back later.
     }
     if (!node.selector.isOperator) {
       // TODO(jgruber): Handle known methods on constants such as String.length.
       setResult(node, lattice.getInvokeReturnType(node.selector, node.mask));
       return;
     }
 
     // Calculate the resulting constant if possible.
@@ skipping 284 matching lines @@
       // null gets returned.
       // TODO(asgerf): Add the NullInterceptor when it enables us to
       //               propagate an assignment.
       setValue(node, nonConstant());
     } else {
       setValue(node, nonConstant(typeSystem.nonNullType));
     }
   }
 
   void visitGetField(GetField node) {
+    node.objectIsNotNull = getValue(node.object.definition).isDefinitelyNotNull;
     setValue(node, nonConstant(typeSystem.getFieldType(node.field)));
   }
 
   void visitSetField(SetField node) {}
 
   void visitCreateBox(CreateBox node) {
     setValue(node, nonConstant(typeSystem.nonNullType));
   }
 
   void visitCreateInstance(CreateInstance node) {
@@ skipping 25 matching lines @@
   @override
   void visitForeignCode(ForeignCode node) {
     if (node.continuation != null) {
       setResult(node, nonConstant(node.type));
     }
   }
 
   @override
   void visitGetLength(GetLength node) {
     AbstractValue input = getValue(node.object.definition);
+    node.objectIsNotNull = getValue(node.object.definition).isDefinitelyNotNull;
     int length = typeSystem.getContainerLength(input.type);
     if (length != null) {
       // TODO(asgerf): Constant-folding the length might degrade the VM's
       // own bounds-check elimination?
       setValue(node, constantValue(new IntConstantValue(length)));
     } else {
       setValue(node, nonConstant(typeSystem.intType));
     }
   }
 
@@ skipping 140 matching lines @@
   processLetPrim(LetPrim node) {
     node.primitive.type = null;
     values[node.primitive] = null;
   }
 
   processLetMutable(LetMutable node) {
     node.variable.type = null;
     values[node.variable] = null;
   }
 }