Add *IndexSetIfNull methods to SemanticSendVisitor.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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 dart2js.ir_builder_task;
 
 import '../closure.dart' as closure;
 import '../common.dart';
 import '../common/names.dart' show
     Identifiers,
@@ skipping 117 matching lines @@
     with IrBuilderMixin<ast.Node>,
          SemanticSendResolvedMixin<ir.Primitive, dynamic>,
          ErrorBulkMixin<ir.Primitive, dynamic>,
          BaseImplementationOfStaticsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfLocalsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfDynamicsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfConstantsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfNewMixin<ir.Primitive, dynamic>,
          BaseImplementationOfCompoundsMixin<ir.Primitive, dynamic>,
          BaseImplementationOfSetIfNullsMixin<ir.Primitive, dynamic>,
-         BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>
+         BaseImplementationOfIndexCompoundsMixin<ir.Primitive, dynamic>,
+         BaseImplementationOfSuperIndexSetIfNullMixin<ir.Primitive, dynamic>
     implements SemanticSendVisitor<ir.Primitive, dynamic> {
   final TreeElements elements;
   final Compiler compiler;
   final SourceInformationBuilder sourceInformationBuilder;
   final TypeMaskSystem typeMaskSystem;
 
   /// A map from try statements in the source to analysis information about
   /// them.
   ///
   /// The analysis information includes the set of variables that must be
@@ skipping 2561 matching lines @@
       ast.Node index,
       ast.Node rhs,
       _) {
     return irBuilder.buildSuperIndexSet(
         function,
         visit(index),
         visit(rhs),
         sourceInformationBuilder.buildIndexSet(node));
   }
 
+  ir.Primitive translateIfNull(
+       ast.SendSet node,
+       ir.Primitive getValue(),
+       ast.Node rhs,
+       void setValue(ir.Primitive value)) {
+    ir.Primitive value = getValue();
+    // Unlike other compound operators if-null conditionally will not do the
+    // assignment operation.
+    return irBuilder.buildIfNull(value, nested(() {
+      ir.Primitive newValue = build(rhs);
+      setValue(newValue);
+      return newValue;
+    }),
+    sourceInformationBuilder.buildIf(node));
+  }
+
   ir.Primitive translateCompounds(
       ast.SendSet node,
       ir.Primitive getValue(),
       CompoundRhs rhs,
       void setValue(ir.Primitive value)) {
     ir.Primitive value = getValue();
     op.BinaryOperator operator = rhs.operator;
-    if (operator.kind == op.BinaryOperatorKind.IF_NULL) {
-      // Unlike other compound operators if-null conditionally will not do the
-      // assignment operation.
-      return irBuilder.buildIfNull(value, nested(() {
-        ir.Primitive newValue = build(rhs.rhs);
-        setValue(newValue);
-        return newValue;
-      }),
-      sourceInformationBuilder.buildIf(node));
-    }
+    assert(operator.kind != op.BinaryOperatorKind.IF_NULL);
 
     Selector operatorSelector =
         new Selector.binaryOperator(operator.selectorName);
     ir.Primitive rhsValue;
     if (rhs.kind == CompoundKind.ASSIGNMENT) {
       rhsValue = visit(rhs.rhs);
     } else {
       rhsValue = irBuilder.buildIntegerConstant(1);
     }
     List<ir.Primitive> arguments = <ir.Primitive>[rhsValue];
@@ skipping 24 matching lines @@
     // assignment operation.
     return irBuilder.buildIfNull(value, nested(() {
       ir.Primitive newValue = build(rhs);
       setValue(newValue);
       return newValue;
     }),
     sourceInformationBuilder.buildIf(node));
   }
 
   @override
+  ir.Primitive handleSuperIndexSetIfNull(
+      ast.SendSet node,
+      Element indexFunction,
+      Element indexSetFunction,
+      ast.Node index,
+      ast.Node rhs,
+      arg,
+      {bool isGetterValid,
+       bool isSetterValid}) {
+    return translateSetIfNull(node, () {
+      if (isGetterValid) {
+        return irBuilder.buildSuperMethodGet(
+            indexFunction, sourceInformationBuilder.buildIndex(node));
+      } else {
+        return buildSuperNoSuchGetter(
+            indexFunction,
+            elements.getGetterTypeMaskInComplexSendSet(node),
+            sourceInformationBuilder.buildIndex(node));
+      }
+    }, rhs, (ir.Primitive result) {
+      if (isSetterValid) {
+        return irBuilder.buildSuperMethodGet(
+            indexSetFunction, sourceInformationBuilder.buildIndexSet(node));
+      } else {
+        return buildSuperNoSuchSetter(
+            indexSetFunction, elements.getTypeMask(node), result,
+            sourceInformationBuilder.buildIndexSet(node));
+      }
+    });
+  }
+
+  @override
+  ir.Primitive visitIndexSetIfNull(
+      ast.SendSet node,
+      ast.Node receiver,
+      ast.Node index,
+      ast.Node rhs,
+      arg) {
+    ir.Primitive target = visit(receiver);
+    ir.Primitive indexValue = visit(index);
+    return translateSetIfNull(node, () {
+      Selector selector = new Selector.index();
+      List<ir.Primitive> arguments = <ir.Primitive>[indexValue];
+      CallStructure callStructure =
+          normalizeDynamicArguments(selector.callStructure, arguments);
+      return irBuilder.buildDynamicInvocation(
+          target,
+          new Selector(selector.kind, selector.memberName, callStructure),
+          elements.getGetterTypeMaskInComplexSendSet(node),
+          arguments,
+          sourceInformationBuilder.buildCall(receiver, node));
+    }, rhs, (ir.Primitive result) {
+      irBuilder.buildDynamicIndexSet(
+          target,
+          elements.getTypeMask(node),
+          indexValue,
+          result,
+          sourceInformationBuilder.buildIndexSet(node));
+    });
+  }
+
+  @override
   ir.Primitive handleDynamicSet(
       ast.SendSet node,
       ast.Node receiver,
       Name name,
       ast.Node rhs,
       _) {
     return irBuilder.buildDynamicSet(
         translateReceiver(receiver),
         new Selector.setter(name),
         elements.getTypeMask(node),
@@ skipping 1466 matching lines @@
     _backend.jsInteropAnalysis.hasAnonymousAnnotation(element.contextClass);
 
   String getJsInteropTargetPath(FunctionElement element) {
     return '${_backend.namer.fixedBackendPath(element)}.'
       '${_backend.nativeData.getFixedBackendName(element)}';
   }
 
   DartType get jsJavascriptObjectType =>
     _backend.helpers.jsJavaScriptObjectClass.thisType;
 }