Refactor IrBuilder to use SemanticVisitor.

pkg/compiler/lib/src/resolution/send_resolver.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.
 
 part of dart2js.semantics_visitor;
 
 enum SendStructureKind {
   GET,
   SET,
   INVOKE,
   UNARY,
   NOT,
   BINARY,
   EQ,
   NOT_EQ,
   COMPOUND,
   INDEX,
   INDEX_SET,
   COMPOUND_INDEX_SET,
   PREFIX,
   POSTFIX,
+  INDEX_PREFIX,
+  INDEX_POSTFIX,
 }
 
 abstract class SendResolverMixin {
   TreeElements get elements;
 
   internalError(Spannable spannable, String message);
 
   AccessSemantics handleStaticallyResolvedAccess(Send node,
                                                  Element element,
                                                  Element getter) {
@@ skipping 146 matching lines @@
               kind = SendStructureKind.EQ;
               break;
             case BinaryOperatorKind.NOT_EQ:
               if (node.isSuperCall) {
                 // `super != foo` is a compile-time error.
                 return const InvalidBinaryStructure();
               }
               kind = SendStructureKind.NOT_EQ;
               break;
             case BinaryOperatorKind.INDEX:
-              if (node.arguments.tail.isEmpty) {
+              if (node.isPrefix) {
+                kind = SendStructureKind.INDEX_PREFIX;
+              } else if (node.isPostfix) {
+                kind = SendStructureKind.INDEX_POSTFIX;
+              } else if (node.arguments.tail.isEmpty) {
                 // a[b]
                 kind = SendStructureKind.INDEX;
               } else {
                 if (kind == SendStructureKind.COMPOUND) {
                   // a[b] += c
                   kind = SendStructureKind.COMPOUND_INDEX_SET;
                 } else {
                   // a[b] = c
                   kind = SendStructureKind.INDEX_SET;
                 }
               }
               break;
             default:
               kind = SendStructureKind.BINARY;
               break;
           }
         } else {
           return const InvalidBinaryStructure();
         }
       }
     }
     AccessSemantics semantics = computeAccessSemantics(
         node,
         isGetOrSet: kind == SendStructureKind.GET ||
                     kind == SendStructureKind.SET,
         isInvoke: kind == SendStructureKind.INVOKE,
         isCompound: kind == SendStructureKind.COMPOUND ||
                     kind == SendStructureKind.COMPOUND_INDEX_SET ||
                     kind == SendStructureKind.PREFIX ||
-                    kind == SendStructureKind.POSTFIX);
+                    kind == SendStructureKind.POSTFIX ||
+                    kind == SendStructureKind.INDEX_PREFIX ||
+                    kind == SendStructureKind.INDEX_POSTFIX);
     if (semantics == null) {
       return internalError(node, 'No semantics for $node');
     }
     Selector selector = elements.getSelector(node);
     switch (kind) {
       case SendStructureKind.GET:
         return new GetStructure(semantics, selector);
       case SendStructureKind.SET:
         return new SetStructure(semantics, selector);
       case SendStructureKind.INVOKE:
@@ skipping 22 matching lines @@
       case SendStructureKind.INDEX_SET:
         return new IndexSetStructure(semantics, selector);
       case SendStructureKind.COMPOUND_INDEX_SET:
         Selector getterSelector =
             elements.getGetterSelectorInComplexSendSet(node);
         return new CompoundIndexSetStructure(
             semantics,
             assignmentOperator,
             getterSelector,
             selector);
+      case SendStructureKind.INDEX_PREFIX:
+        Selector getterSelector =
+            elements.getGetterSelectorInComplexSendSet(node);
+        return new IndexPrefixStructure(
+            semantics,
+            incDecOperator,
+            getterSelector,
+            selector);
+      case SendStructureKind.INDEX_POSTFIX:
+        Selector getterSelector =
+            elements.getGetterSelectorInComplexSendSet(node);
+        return new IndexPostfixStructure(
+            semantics,
+            incDecOperator,
+            getterSelector,
+            selector);
       case SendStructureKind.PREFIX:
         Selector getterSelector =
             elements.getGetterSelectorInComplexSendSet(node);
         return new PrefixStructure(
             semantics,
             incDecOperator,
             getterSelector,
             selector);
       case SendStructureKind.POSTFIX:
         Selector getterSelector =
@@ skipping 97 matching lines @@
         // TODO(johnniwinther): Provide an [ErroneousElement].
         // This happens for code like `C.this`.
         return new StaticAccess.unresolved(null);
       } else {
         return handleStaticallyResolvedAccess(node, element, getter);
       }
     }
   }
 }