[dart2js] fix inference of ??= and []??=

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

Index: pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
diff --git a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
index d40a34919a4268ee51a59272ed6bd19c1672ca2e..5e6d0ec57be81659a6dfe08c8ab88d39dfcb1d83 100644
--- a/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
+++ b/pkg/compiler/lib/src/inferrer/simple_types_inferrer.dart
@@ -822,8 +822,6 @@ class SimpleTypeInferrerVisitor<T>
         elements.getGetterSelectorInComplexSendSet(node);
     TypeMask getterMask =
         elements.getGetterTypeMaskInComplexSendSet(node);
-    Selector operatorSelector =
-        elements.getOperatorSelectorInComplexSendSet(node);
     TypeMask operatorMask =
         elements.getOperatorTypeMaskInComplexSendSet(node);
     Selector setterSelector = elements.getSelector(node);
@@ -882,53 +880,53 @@ class SimpleTypeInferrerVisitor<T>
           node, element, setterSelector, setterMask, receiverType, rhsType,
           node.arguments.head);
     } else {
-      // [: foo++ :] or [: foo += 1 :].
-      ArgumentsTypes operatorArguments = new ArgumentsTypes<T>([rhsType], null);
+      // [foo ??= bar], [: foo++ :] or [: foo += 1 :].
       T getterType;
       T newType;
-      if (Elements.isErroneous(element)) {
-        getterType = types.dynamicType;
-        newType = types.dynamicType;
-      } else if (Elements.isStaticOrTopLevelField(element)) {
+
+      if (Elements.isErroneous(element)) return types.dynamicType;
+
+      if (Elements.isStaticOrTopLevelField(element)) {
         Element getterElement = elements[node.selector];
         getterType = handleStaticSend(
             node, getterSelector, getterMask, getterElement, null);
-        newType = handleDynamicSend(
-            node, operatorSelector, operatorMask,
-            getterType, operatorArguments);
-        handleStaticSend(
-            node, setterSelector, setterMask, element,
-            new ArgumentsTypes<T>([newType], null));
       } else if (Elements.isUnresolved(element)

[Siggi Cherem (dart-lang), 2015/08/20 01:39:47]

BTW - this looks like a bigger change than it is - there is very little new code
here.

Basically the code had this structure:

   1. for each condition:
     1.1 compute getterType
     1.2 compute newType by doing the getter & operator send
     1.3 handle the assignment through the setter


1.2 was identical in all cases, so I changed it to have this structure instead:


   1. for each condition:
     1.1 compute getterType

   2. compute newType by doing the getter & operator send

   3. for each condition:
     3.3 handle the assignment (as before)


and then modified #2 to include the logic for `??=`

                  || element.isSetter
                  || element.isField) {
         getterType = handleDynamicSend(
             node, getterSelector, getterMask, receiverType, null);
-        newType = handleDynamicSend(
-            node, operatorSelector, operatorMask,
-            getterType, operatorArguments);
-        handleDynamicSend(node, setterSelector, setterMask, receiverType,
-                          new ArgumentsTypes<T>([newType], null));
       } else if (element.isLocal) {
         LocalElement local = element;
         getterType = locals.use(local);
-        newType = handleDynamicSend(
-            node, operatorSelector, operatorMask,
-            getterType, operatorArguments);
-        locals.update(element, newType, node);
       } else {
         // Bogus SendSet, for example [: myMethod += 42 :].
         getterType = types.dynamicType;
+      }
+
+      if (op == '??=') {
+        newType = types.allocateDiamondPhi(getterType, rhsType);
+      } else {
+        Selector operatorSelector =
+          elements.getOperatorSelectorInComplexSendSet(node);
         newType = handleDynamicSend(
             node, operatorSelector, operatorMask,
-            getterType, operatorArguments);
+            getterType, new ArgumentsTypes<T>([rhsType], null));
       }
 
-      if (node.isPostfix) {
-        return getterType;
-      } else {
-        return newType;
+      if (Elements.isStaticOrTopLevelField(element)) {
+        handleStaticSend(
+            node, setterSelector, setterMask, element,
+            new ArgumentsTypes<T>([newType], null));
+      } else if (Elements.isUnresolved(element)
+                 || element.isSetter
+                 || element.isField) {
+        handleDynamicSend(node, setterSelector, setterMask, receiverType,
+                          new ArgumentsTypes<T>([newType], null));
+      } else if (element.isLocal) {
+        locals.update(element, newType, node);
       }
+
+      return node.isPostfix ? getterType : newType;
     }
   }
 
@@ -955,12 +953,18 @@ class SimpleTypeInferrerVisitor<T>
         getterMask,
         receiverType,
         new ArgumentsTypes<T>([indexType], null));
-    T returnType = handleDynamicSend(
-        node,
-        operatorSelector,
-        operatorMask,
-        getterType,
-        new ArgumentsTypes<T>([rhsType], null));
+
+    T returnType;
+    if (node.isIfNullAssignment) {
+      returnType = types.allocateDiamondPhi(getterType, rhsType);
+    } else {
+      returnType = handleDynamicSend(
+          node,
+          operatorSelector,
+          operatorMask,
+          getterType,
+          new ArgumentsTypes<T>([rhsType], null));
+    }
     handleDynamicSend(
         node,
         setterSelector,