Implementation of null-aware operators.

pkg/compiler/lib/src/inferrer/inferrer_visitor.dart

 // Copyright (c) 2013, 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 inferrer_visitor;
 
 import '../constants/constant_system.dart';
 import '../constants/expressions.dart';
 import '../dart2jslib.dart' hide Selector, TypedSelector;
 import '../dart_types.dart';
@@ skipping 97 matching lines @@
 
   /**
    * Returns `true` if `selector` should be updated to reflect the new
    * `receiverType`.
    */
   bool selectorNeedsUpdate(T receiverType, Selector selector);
 
   /**
    * Returns a new receiver type for this [selector] applied to
    * [receiverType].
+   *
+   * The option [isConditional] is true when [selector] was seen in a
+   * conditional send (e.g.  `a?.selector`), in which case the returned type may
+   * be null.
    */
-  T refineReceiver(Selector selector, T receiverType);
+  T refineReceiver(Selector selector, T receiverType, bool isConditional);
 
   /**
    * Returns the internal inferrer representation for [mask].
    */
   T getConcreteTypeFor(TypeMask mask);
 }
 
 /**
  * A variable scope holds types for variables. It has a link to a
  * parent scope, but never changes the types in that parent. Instead,
@@ skipping 304 matching lines @@
     }
   }
 
   void update(LocalElement local, T type, Node node) {
     assert(type != null);
     if (compiler.trustTypeAnnotations || compiler.enableTypeAssertions) {
       type = types.narrowType(type, local.type);
     }
     updateLocal() {
       T currentType = locals[local];
+
+      SendSet send = node != null ? node.asSendSet() : null;
+      if (send != null && send.isIfNullAssignment && currentType != null) {
+        // If-null assignments may return either the new or the original value.
+        type = types.addPhiInput(
+            local, types.allocatePhi(locals.block, local, currentType), type);
+      }
       locals[local] = type;
       if (currentType != type) {
         inferrer.recordLocalUpdate(local, type);
       }
     }
     if (capturedAndBoxed.containsKey(local)) {
       inferrer.recordTypeOfNonFinalField(
           node, capturedAndBoxed[local], type);
     } else if (inTryBlock) {
       // We don't know if an assignment in a try block
@@ skipping 527 matching lines @@
   T visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       _) {
     return handleDynamicInvoke(node);
   }
 
   @override
+  T visitIfNotNullDynamicPropertyInvoke(
+      Send node,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      _) {
+    return handleDynamicInvoke(node);
+  }
+
+  @override
   T visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       _) {
     return handleDynamicInvoke(node);
   }
 
   @override
+  T visitIfNull(Send node, Node left, Node right, _) {
+    T firstType = visit(left);
+    T secondType = visit(right);
+    return types.allocateDiamondPhi(firstType, secondType);
+  }
+
+  @override
   T visitLogicalAnd(Send node, Node left, Node right, _) {
     conditionIsSimple = false;
     bool oldAccumulateIsChecks = accumulateIsChecks;
     List<Send> oldIsChecks = isChecks;
     if (!accumulateIsChecks) {
       accumulateIsChecks = true;
       isChecks = <Send>[];
     }
     visit(left);
     LocalsHandler<T> saved = locals;
@@ skipping 402 matching lines @@
     return type;
   }
 
   T visitCascade(Cascade node) {
     // Ignore the result of the cascade send and return the type of the cascade
     // receiver.
     visit(node.expression);
     return cascadeReceiverStack.removeLast();
   }
 }