Update SemanticVisitor with visitIndex, visitSuperIndex

tests/compiler/dart2js/semantic_visitor_test.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.semantics_visitor_test;
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/dart_types.dart';
@@ skipping 1026 matching lines @@
     const Test(
         '''
         m() => 2 ^ 3;
         ''',
         const Visit(VisitKind.VISIT_BINARY,
                     left: '2', operator: '^', right: '3')),
     const Test(
         '''
         m() => 2[3];
         ''',
-        const Visit(VisitKind.VISIT_BINARY,
-                    left: '2', operator: '[]', right: '3')),
+        const Visit(VisitKind.VISIT_INDEX,
+                    receiver: '2', index: '3')),
     const Test.clazz(
         '''
         class B {
           operator +(_) => null;
         }
         class C extends B {
           m() => super + 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_BINARY,
                     element: 'function(B#+)',
                     operator: '+',
                     right: '42')),
+    const Test.clazz(
+        '''
+        class B {
+          operator [](_) => null;
+        }
+        class C extends B {
+          m() => super[42];
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_INDEX,
+                    element: 'function(B#[])',
+                    index: '42')),
 
     // Equals
     const Test(
         '''
         m() => 2 == 3;
         ''',
         const Visit(VisitKind.VISIT_EQUALS,
                     left: '2', right: '3')),
     const Test.clazz(
         '''
@@ skipping 997 matching lines @@
       BinaryOperator operator,
       Node right,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_BINARY,
         left: left, operator: operator, right: right));
     apply(left, arg);
     apply(right, arg);
   }
 
   @override
+  visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_INDEX,
+        receiver: receiver, index: index));
+    apply(receiver, arg);
+    apply(index, arg);
+  }
+
+  @override
   visitClassTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_GET,
         constant: constant.getText()));
   }
 
   @override
   visitClassTypeLiteralInvoke(
@@ skipping 353 matching lines @@
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_BINARY,
             element: function, operator: operator, right: argument));
     apply(argument, arg);
   }
 
   @override
+  visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX,
+            element: function, index: index));
+    apply(index, arg);
+  }
+
+  @override
   visitSuperNotEquals(
       Send node,
       FunctionElement function,
       Node argument,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_NOT_EQUALS,
             element: function, right: argument));
     apply(argument, arg);
   }
 
@@ skipping 795 matching lines @@
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_COMPOUND_INDEX_SET,
         getter: getter, setter: setter,
         index: index, rhs: rhs, operator: operator));
     apply(index, arg);
     apply(rhs, arg);
   }
 
   @override
-  visitClassTypeLiteralCompound(
+  errorClassTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitDynamicTypeLiteralCompound(
+  errorDynamicTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitTypeVariableTypeLiteralCompound(
+  errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
         element: element, operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitTypedefTypeLiteralCompound(
+  errorTypedefTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
   errorLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
     // TODO: implement errorLocalFunctionPrefix
   }
 
   @override
-  visitClassTypeLiteralPrefix(
+  errorClassTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitDynamicTypeLiteralPrefix(
+  errorDynamicTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   visitLocalVariablePrefix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_PREFIX,
@@ skipping 141 matching lines @@
   visitTopLevelMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
     // TODO: implement visitTopLevelMethodSetterPrefix
   }
 
   @override
-  visitTypeVariableTypeLiteralPrefix(
+  errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
         element: element, operator: operator));
   }
 
   @override
-  visitTypedefTypeLiteralPrefix(
+  errorTypedefTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   errorLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
     // TODO: implement errorLocalFunctionPostfix
   }
 
   @override
-  visitClassTypeLiteralPostfix(
+  errorClassTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitDynamicTypeLiteralPostfix(
+  errorDynamicTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_POSTFIX,
@@ skipping 141 matching lines @@
   visitTopLevelMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
     // TODO: implement visitTopLevelMethodSetterPostfix
   }
 
   @override
-  visitTypeVariableTypeLiteralPostfix(
+  errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
         element: element, operator: operator));
   }
 
   @override
-  visitTypedefTypeLiteralPostfix(
+  errorTypedefTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   visitConstantGet(
       Send node,
       ConstantExpression constant,
       arg) {
     // TODO: implement visitConstantGet
   }
@@ skipping 210 matching lines @@
   VISIT_SUPER_GETTER_FIELD_PREFIX,
   VISIT_SUPER_FIELD_SETTER_PREFIX,
   VISIT_SUPER_GETTER_SETTER_POSTFIX,
   VISIT_SUPER_GETTER_FIELD_POSTFIX,
   VISIT_SUPER_FIELD_SETTER_POSTFIX,
 
   VISIT_SUPER_METHOD_GET,
   VISIT_SUPER_METHOD_INVOKE,
 
   VISIT_BINARY,
+  VISIT_INDEX,
   VISIT_EQUALS,
   VISIT_NOT_EQUALS,
 
   VISIT_SUPER_BINARY,
+  VISIT_SUPER_INDEX,
   VISIT_SUPER_EQUALS,
   VISIT_SUPER_NOT_EQUALS,
 
   VISIT_UNARY,
   VISIT_SUPER_UNARY,
   VISIT_NOT,
 
   VISIT_EXPRESSION_INVOKE,
 
   VISIT_CLASS_TYPE_LITERAL_GET,
   VISIT_CLASS_TYPE_LITERAL_SET,
   VISIT_CLASS_TYPE_LITERAL_INVOKE,
   VISIT_CLASS_TYPE_LITERAL_BINARY,
-  VISIT_CLASS_TYPE_LITERAL_COMPOUND,
-  VISIT_CLASS_TYPE_LITERAL_PREFIX,
-  VISIT_CLASS_TYPE_LITERAL_POSTFIX,
+  ERROR_CLASS_TYPE_LITERAL_COMPOUND,
+  ERROR_CLASS_TYPE_LITERAL_PREFIX,
+  ERROR_CLASS_TYPE_LITERAL_POSTFIX,
 
   VISIT_TYPEDEF_TYPE_LITERAL_GET,
   VISIT_TYPEDEF_TYPE_LITERAL_SET,
   VISIT_TYPEDEF_TYPE_LITERAL_INVOKE,
   VISIT_TYPEDEF_TYPE_LITERAL_BINARY,
-  VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
-  VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
-  VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
+  ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
+  ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
+  ERROR_TYPEDEF_TYPE_LITERAL_POSTFIX,
 
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_GET,
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_SET,
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_INVOKE,
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_BINARY,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+  ERROR_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+  ERROR_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+  ERROR_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
 
   VISIT_DYNAMIC_TYPE_LITERAL_GET,
   VISIT_DYNAMIC_TYPE_LITERAL_SET,
   VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
   VISIT_DYNAMIC_TYPE_LITERAL_BINARY,
-  VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
-  VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
-  VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
+  ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
+  ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
+  ERROR_DYNAMIC_TYPE_LITERAL_POSTFIX,
 
   VISIT_INDEX_SET,
   VISIT_COMPOUND_INDEX_SET,
   VISIT_SUPER_INDEX_SET,
   VISIT_SUPER_COMPOUND_INDEX_SET,
 
   VISIT_ASSERT,
   VISIT_LOGICAL_AND,
   VISIT_LOGICAL_OR,
   VISIT_IS,
   VISIT_IS_NOT,
   VISIT_AS,
 
   // TODO(johnniwinther): Add tests for error cases.
 }