Update SemanticVisitor with visitIndex, visitSuperIndex

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 688 matching lines @@
   @override
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     return visitor.errorUndefinedUnaryExpression(
         node,
         node.selector,
         node.receiver,
         arg);
   }
 }
 
+/// The structure for a [Send] that is an index expression, i.e. of the form
+/// `a[b]`.
+class IndexStructure<R, A> implements SendStructure<R, A> {
+  /// The target of the left operand.
+  final AccessSemantics semantics;
+
+  // TODO(johnniwinther): Should we store this?
+  /// The [Selector] for the `[]` invocation.
+  final Selector selector;
+
+  IndexStructure(this.semantics, this.selector);
+
+  R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
+    switch (semantics.kind) {
+      case AccessKind.DYNAMIC_PROPERTY:
+        return visitor.visitIndex(
+            node,
+            node.receiver,
+            node.arguments.single,
+            arg);
+      case AccessKind.SUPER_METHOD:
+        return visitor.visitSuperIndex(
+            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`.
 class EqualsStructure<R, A> implements SendStructure<R, A> {
   /// The target of the left operand.
   final AccessSemantics semantics;
 
   // TODO(johnniwinther): Should we store this?
   /// The [Selector] for the `==` invocation.
   final Selector selector;
 
@@ skipping 240 matching lines @@
       case AccessKind.TOPLEVEL_METHOD:
         // TODO(johnniwinther): Handle this.
         break;
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.visitClassTypeLiteralCompound(
+        return visitor.errorClassTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.visitTypedefTypeLiteralCompound(
+        return visitor.errorTypedefTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.visitDynamicTypeLiteralCompound(
+        return visitor.errorDynamicTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.visitTypeVariableTypeLiteralCompound(
+        return visitor.errorTypeVariableTypeLiteralCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
@@ skipping 245 matching lines @@
       case AccessKind.TOPLEVEL_METHOD:
         // TODO(johnniwinther): Handle this.
         break;
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.visitClassTypeLiteralPrefix(
+        return visitor.errorClassTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.visitTypedefTypeLiteralPrefix(
+        return visitor.errorTypedefTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.visitDynamicTypeLiteralPrefix(
+        return visitor.errorDynamicTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.visitTypeVariableTypeLiteralPrefix(
+        return visitor.errorTypeVariableTypeLiteralPrefix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
         break;
@@ skipping 173 matching lines @@
       case AccessKind.TOPLEVEL_METHOD:
         // TODO(johnniwinther): Handle this.
         break;
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.visitClassTypeLiteralPostfix(
+        return visitor.errorClassTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.visitTypedefTypeLiteralPostfix(
+        return visitor.errorTypedefTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.visitDynamicTypeLiteralPostfix(
+        return visitor.errorDynamicTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.visitTypeVariableTypeLiteralPostfix(
+        return visitor.errorTypeVariableTypeLiteralPostfix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
         break;
@@ skipping 94 matching lines @@
                 compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 }