dart2js: Type inferrence: Account for implicit null test in '??' and '??='.

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 'dart:collection' show
     IterableMixin;
 
 import '../common.dart';
@@ skipping 73 matching lines @@
   T computeLUB(T firstType, T secondType);
 
   /**
    * Returns the intersection between [T] and [annotation].
    * [isNullable] indicates whether the annotation implies a null
    * type.
    */
   T narrowType(T type, DartType annotation, {bool isNullable: true});
 
   /**
+   * Returns the non-nullable type [T].
+   */
+  T narrowNotNull(T type);
+
+  /**
    * Returns a new type that unions [firstInput] and [secondInput].
    */
   T allocateDiamondPhi(T firstInput, T secondInput);
 
   /**
    * Returns a new type for holding the potential types of [element].
    * [inputType] is the first incoming type of the phi.
    */
   T allocatePhi(Node node, Local variable, T inputType);
 
@@ skipping 358 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.
+        // If-null assignments may return either the new or the original value
+        // narrowed to non-null.
         type = types.addPhiInput(
-            local, types.allocatePhi(locals.block, local, currentType), type);
+            local,
+            types.allocatePhi(locals.block, local,
+                              types.narrowNotNull(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) {
@@ skipping 632 matching lines @@
       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);
+    return types.allocateDiamondPhi(types.narrowNotNull(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>[];
@@ skipping 405 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();
   }
 }