Add *IndexSetIfNull methods to SemanticSendVisitor.

pkg/compiler/lib/src/resolution/send_structure.dart

 // Copyright (c) 2015, 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.resolution.send_structure;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../elements/elements.dart';
@@ skipping 1972 matching lines @@
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid compound index set: ${semantics}");
   }
 
   String toString() => 'compound []=($operator,$semantics)';
 }
 
+/// The structure for a [Send] that is a if-null assignment on the index
+/// operator. For instance `a[b] ??= c`.
+class IndexSetIfNullStructure<R, A> implements SendStructure<R, A> {
+  /// The target of the index operations.
+  final AccessSemantics semantics;
+
+  IndexSetIfNullStructure(this.semantics);
+
+  R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
+    switch (semantics.kind) {
+      case AccessKind.EXPRESSION:
+        return visitor.visitIndexSetIfNull(
+            node,
+            node.receiver,
+            node.arguments.first,
+            node.arguments.tail.head,
+            arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperIndexSetIfNull(
+            node,
+            semantics.element,
+            node.arguments.first,
+            node.arguments.tail.head,
+            arg);
+      case AccessKind.INVALID:
+        return visitor.errorInvalidIndexSetIfNull(
+            node,
+            semantics.element,
+            node.arguments.first,
+            node.arguments.tail.head,
+            arg);
+      case AccessKind.COMPOUND:
+        CompoundAccessSemantics compoundSemantics = semantics;
+        switch (compoundSemantics.compoundAccessKind) {
+          case CompoundAccessKind.SUPER_GETTER_SETTER:
+            return visitor.visitSuperIndexSetIfNull(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.first,
+                node.arguments.tail.head,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterIndexSetIfNull(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.first,
+                node.arguments.tail.head,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            return visitor.visitUnresolvedSuperSetterIndexSetIfNull(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.first,
+                node.arguments.tail.head,
+                arg);
+          default:
+            // This is not a valid case.
+            break;
+        }
+        break;
+      default:
+        // This is not a valid case.
+        break;
+    }
+    throw new SpannableAssertionFailure(
+        node, "Invalid index set if-null: ${semantics}");
+  }
+
+  String toString() => 'index set if-null []??=($semantics)';
+}
+
 /// The structure for a [Send] that is a prefix operations. For instance
 /// `++a`.
 class PrefixStructure<R, A> implements SendStructure<R, A> {
   /// The target of the prefix operation.
   final AccessSemantics semantics;
 
   /// The `++` or `--` operator used in the operation.
   final IncDecOperator operator;
 
   PrefixStructure(this.semantics,
@@ skipping 1015 matching lines @@
   ThisConstructorInvokeStructure(
       this.node, this.constructor, this.callStructure);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, callStructure, arg);
   }
 
   bool get isConstructorInvoke => true;
 }