Refactor IrBuilder to use SemanticVisitor.

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.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../tree/tree.dart';
@@ skipping 714 matching lines @@
             node,
             node.receiver,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperIndex(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.errorUnresolvedSuperIndex(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(node, "Invalid index: ${semantics}");
   }
 }
 
 /// The structure for a [Send] that is an equals test, i.e. of the form
 /// `a == b`.
@@ skipping 163 matching lines @@
             arg);
       default:
         // This is not a valid case.
         break;
     }
     throw new SpannableAssertionFailure(
         node, "Invalid index set: ${semantics}");
   }
 }
 
+/// The structure for a [Send] that is an prefix operation on an index
+/// expression, i.e. of the form `--a[b]`.
+class IndexPrefixStructure<R, A> implements SendStructure<R, A> {
+  /// The target of the left operand.
+  final AccessSemantics semantics;
+
+  /// The `++` or `--` operator used in the operation.
+  final IncDecOperator operator;
+
+  // TODO(johnniwinther): Should we store this?
+  /// The [Selector] for the `[]` invocation.
+  final Selector getterSelector;
+
+  // TODO(johnniwinther): Should we store this?
+  /// The [Selector] for the `[]=` invocation.
+  final Selector setterSelector;
+
+  IndexPrefixStructure(this.semantics,
+                       this.operator,
+                       this.getterSelector,
+                       this.setterSelector);
+
+  R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
+    switch (semantics.kind) {
+      case AccessKind.DYNAMIC_PROPERTY:
+        return visitor.visitIndexPrefix(
+            node,
+            node.receiver,
+            node.arguments.single,
+            operator,
+            arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.errorUnresolvedSuperIndexPrefix(
+            node,
+            semantics.element,
+            node.arguments.single,
+            operator,
+            arg);
+      case AccessKind.COMPOUND:
+        CompoundAccessSemantics compoundSemantics = semantics;
+        switch (compoundSemantics.compoundAccessKind) {
+          case CompoundAccessKind.SUPER_GETTER_SETTER:
+            return visitor.visitSuperIndexPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.single,
+                operator,
+                arg);
+          default:
+            // This is not a valid case.
+            break;
+        }
+        break;
+      default:
+        // This is not a valid case.
+        break;
+    }
+    throw new SpannableAssertionFailure(
+        node, "Invalid index prefix: ${semantics}");
+  }
+}
+
+/// The structure for a [Send] that is an postfix operation on an index
+/// expression, i.e. of the form `a[b]++`.
+class IndexPostfixStructure<R, A> implements SendStructure<R, A> {
+  /// The target of the left operand.
+  final AccessSemantics semantics;
+
+  /// The `++` or `--` operator used in the operation.
+  final IncDecOperator operator;
+
+  // TODO(johnniwinther): Should we store this?
+  /// The [Selector] for the `[]` invocation.
+  final Selector getterSelector;
+
+  // TODO(johnniwinther): Should we store this?
+  /// The [Selector] for the `[]=` invocation.
+  final Selector setterSelector;
+
+  IndexPostfixStructure(this.semantics,
+                        this.operator,
+                        this.getterSelector,
+                        this.setterSelector);
+
+  R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
+    switch (semantics.kind) {
+      case AccessKind.DYNAMIC_PROPERTY:
+        return visitor.visitIndexPostfix(
+            node,
+            node.receiver,
+            node.arguments.single,
+            operator,
+            arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.errorUnresolvedSuperIndexPostfix(
+            node,
+            semantics.element,
+            node.arguments.single,
+            operator,
+            arg);
+      case AccessKind.COMPOUND:
+        CompoundAccessSemantics compoundSemantics = semantics;
+        switch (compoundSemantics.compoundAccessKind) {
+          case CompoundAccessKind.SUPER_GETTER_SETTER:
+            return visitor.visitSuperIndexPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                node.arguments.single,
+                operator,
+                arg);
+          default:
+            // This is not a valid case.
+            break;
+        }
+        break;
+      default:
+        // This is not a valid case.
+        break;
+    }
+    throw new SpannableAssertionFailure(
+        node, "Invalid index postfix: ${semantics}");
+  }
+}
+
 /// The structure for a [Send] that is a compound assignment. For instance
 /// `a += b`.
 class CompoundStructure<R, A> implements SendStructure<R, A> {
   /// The target of the compound assignment, i.e. the left-hand side.
   final AccessSemantics semantics;
 
   /// The assignment operator used in the compound assignment.
   final AssignmentOperator operator;
 
   /// The [Selector] for the getter invocation.
@@ skipping 697 matching lines @@
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 }