Refactor IrBuilder to use SemanticVisitor.

pkg/compiler/lib/src/resolution/semantic_visitor_mixins.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;
 
 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
@@ skipping 461 matching lines @@
       SendSet node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
+  R errorUnresolvedSuperIndex(
+      Send node,
+      Element function,
+      Node index,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorUnresolvedSuperIndexPostfix(
+      Send node,
+      Element function,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorUnresolvedSuperIndexPrefix(
+      Send node,
+      Element function,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
   R errorUnresolvedSuperIndexSet(
       SendSet node,
       Element element,
       Node index,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
@@ skipping 52 matching lines @@
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return bulkHandlePrefix(node);
   }
 
   @override
+  R visitIndexPrefix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePrefix(node);
+  }
+
+  @override
   R visitLocalVariablePrefix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node);
   }
 
   @override
   R visitParameterPrefix(
@@ skipping 76 matching lines @@
   R visitSuperGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node);
   }
 
   @override
+  R visitSuperIndexPrefix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePrefix(node);
+  }
+
+  @override
   R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node);
   }
 
   @override
@@ skipping 53 matching lines @@
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return bulkHandlePostfix(node);
   }
 
   @override
+  R visitIndexPostfix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node);
+  }
+
+  @override
   R visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node);
   }
 
   @override
   R visitParameterPostfix(
@@ skipping 76 matching lines @@
   R visitSuperGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node);
   }
 
   @override
+  R visitSuperIndexPostfix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node);
+  }
+
+  @override
   R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node);
   }
 
   @override
@@ skipping 1603 matching lines @@
   R errorTypedefTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
+  R errorUnresolvedSuperIndex(
+      Send node,
+      Element function,
+      Node index,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
   R visitAs(
       Send node,
       Node expression,
       DartType type,
       A arg) {
     apply(expression, arg);
     return null;
   }
 
   @override
@@ skipping 1428 matching lines @@
   }
 
   @override
   R errorUnresolvedSuperUnary(
       Send node,
       UnaryOperator operator,
       Element element,
       A arg) {
     return null;
   }
+
+  @override
+  R errorUnresolvedSuperIndexPostfix(
+      Send node,
+      Element function,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement errorUnresolvedSuperIndexPostfix
+  }
+
+  @override
+  R errorUnresolvedSuperIndexPrefix(
+      Send node,
+      Element function,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement errorUnresolvedSuperIndexPrefix
+  }
+
+  @override
+  R visitIndexPostfix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitIndexPostfix
+  }
+
+  @override
+  R visitIndexPrefix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitIndexPrefix
+  }
+
+  @override
+  R visitSuperIndexPostfix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitSuperIndexPostfix
+  }
+
+  @override
+  R visitSuperIndexPrefix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitSuperIndexPrefix
+  }
 }
 
 /// AST visitor that visits all normal [Send] and [SendSet] nodes using the
 /// [SemanticVisitor].
 class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
     with TraversalMixin<R, A> {
   TraversalVisitor(TreeElements elements) : super(elements);
 
   SemanticSendVisitor<R, A> get sendVisitor => this;
 
@@ skipping 40 matching lines @@
     }
     return null;
   }
 }
 
 /// Mixin that groups all `visitStaticX` and `visitTopLevelX` method by
 /// delegating calls to `handleStaticX` methods.
 ///
 /// This mixin is useful for the cases where both top level members and static
 /// class members are handled uniformly.
-abstract class GroupStaticMixin<R, A> implements SemanticSendVisitor<R, A> {
+abstract class BaseImplementationOfStaticsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
   R handleStaticFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   R handleStaticFieldGet(
       Send node,
       FieldElement field,
@@ skipping 420 matching lines @@
       A arg) {
     return handleStaticSetterSet(node, setter, rhs, arg);
   }
 }
 
 /// Mixin that groups all `visitLocalX` and `visitParameterX` method by
 /// delegating calls to `handleLocalX` methods.
 ///
 /// This mixin is useful for the cases where both parameters, local variables,
 /// and local functions, captured or not, are handled uniformly.
-abstract class GroupLocalMixin<R, A> implements SemanticSendVisitor<R, A> {
+abstract class BaseImplementationOfLocalsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
   R handleLocalCompound(
       Send node,
       LocalElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   R handleLocalGet(
       Send node,
       LocalElement element,
@@ skipping 150 matching lines @@
       A arg) {
     return handleLocalSet(node, parameter, rhs, arg);
   }
 }
 
 /// Mixin that groups all `visitConstantX` and `visitXTypeLiteralY` methods for
 /// constant type literals by delegating calls to `handleConstantX` methods.
 ///
 /// This mixin is useful for the cases where expressions on constants are
 /// handled uniformly.
-abstract class GroupConstantMixin<R, A> implements SemanticSendVisitor<R, A> {
+abstract class BaseImplementationOfConstantsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
   R handleConstantGet(
       Send node,
       ConstantExpression constant,
       A arg);
 
   R handleConstantInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       Selector selector,
@@ skipping 71 matching lines @@
     return handleConstantInvoke(node, constant, arguments, selector, arg);
   }
 }
 
 /// Mixin that groups all `visitDynamicPropertyX` and `visitThisPropertyY`
 /// methods for by delegating calls to `handleDynamicX` methods, providing
 /// `null` as the receiver for the this properties.
 ///
 /// This mixin is useful for the cases where dynamic and this properties are
 /// handled uniformly.
-abstract class GroupDynamicMixin<R, A> implements SemanticSendVisitor<R, A> {
+abstract class BaseImplementationOfDynamicsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
   R handleDynamicCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       A arg);
 
   R handleDynamicGet(
@@ skipping 18 matching lines @@
       A arg,
       {bool isPrefix});
 
   R handleDynamicSet(
       SendSet node,
       Node receiver,
       Selector selector,
       Node rhs,
       A arg);
 
+  R handleDynamicIndexPostfixPrefix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return handleDynamicCompound(
@@ skipping 109 matching lines @@
   }
 
   @override
   R visitThisPropertySet(
       SendSet node,
       Selector selector,
       Node rhs,
       A arg) {
     return handleDynamicSet(node, null, selector, rhs, arg);
   }
+
+  @override
+  R visitIndexPostfix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return handleDynamicIndexPostfixPrefix(
+        node, receiver, index, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitIndexPrefix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return handleDynamicIndexPostfixPrefix(
+        node, receiver, index, operator, arg, isPrefix: true);
+  }
 }
 
 /// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods for
 /// by delegating calls to `handleSuperXPostfixPrefix` methods.
 ///
 /// This mixin is useful for the cases where super prefix/postfix expression are
 /// handled uniformly.
-abstract class GroupSuperMixin<R, A> implements SemanticSendVisitor<R, A> {
+abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
   R handleSuperFieldFieldPostfixPrefix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg,
       {bool isPrefix});
 
   R handleSuperFieldSetterPostfixPrefix(
       Send node,
@@ skipping 20 matching lines @@
       {bool isPrefix});
 
   R handleSuperMethodSetterPostfixPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg,
       {bool isPrefix});
 
+  R handleSuperIndexPostfixPrefix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
   @override
   R visitSuperFieldFieldPostfix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
     return handleSuperFieldFieldPostfixPrefix(
         node, readField, writtenField, operator, arg, isPrefix: false);
   }
@@ skipping 109 matching lines @@
   @override
   R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return handleSuperMethodSetterPostfixPrefix(
         node, method, setter, operator, arg, isPrefix: true);
   }
+
+  @override
+  R visitSuperIndexPostfix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperIndexPostfixPrefix(
+        node, indexFunction, indexSetFunction,
+        index, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperIndexPrefix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperIndexPostfixPrefix(
+        node, indexFunction, indexSetFunction,
+        index, operator, arg, isPrefix: true);
+  }
 }