Update SemanticVisitor with visitIndex, visitSuperIndex

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.
 abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
   R bulkHandleError(Send node) {
     return bulkHandleNode(node, "Error expression `$node` unhandled.");
   }
 
   @override
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       A arg) {
-    bulkHandleError(node);
+    return bulkHandleError(node);
   }
 
   @override
+  R errorClassTypeLiteralCompound(
+      Send node,
+      TypeConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorClassTypeLiteralPostfix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorClassTypeLiteralPrefix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
   R errorClassTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
+  R errorDynamicTypeLiteralCompound(
+      Send node,
+      TypeConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorDynamicTypeLiteralPostfix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorDynamicTypeLiteralPrefix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
   R errorDynamicTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
   R errorFinalLocalVariableCompound(
@@ skipping 230 matching lines @@
   R errorTopLevelSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
       Selector selector,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
+  R errorTypeVariableTypeLiteralCompound(
+      Send node,
+      TypeVariableElement element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorTypeVariableTypeLiteralPostfix(
+      Send node,
+      TypeVariableElement element,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorTypeVariableTypeLiteralPrefix(
+      Send node,
+      TypeVariableElement element,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
   R errorTypeVariableTypeLiteralSet(
       SendSet node,
       TypeVariableElement element,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
+  R errorTypedefTypeLiteralCompound(
+      Send node,
+      TypeConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorTypedefTypeLiteralPostfix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
+  R errorTypedefTypeLiteralPrefix(
+      Send node,
+      TypeConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandleError(node);
+  }
+
+  @override
   R errorTypedefTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
   R errorUnresolvedCompound(
@@ skipping 45 matching lines @@
   R errorUnresolvedSet(
       Send node,
       Element element,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
   R errorUnresolvedSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
   R errorUnresolvedSuperIndexSet(
-      Send node,
+      SendSet node,
       Element element,
       Node index,
       Node rhs,
       A arg) {
     return bulkHandleError(node);
   }
 
   @override
   R errorUnresolvedSuperBinary(
       Send node,
@@ skipping 39 matching lines @@
 /// Use this mixin to provide a trivial implementation for all `visitXPrefix`
 /// methods.
 abstract class PrefixBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
   R bulkHandlePrefix(Send node) {
     return bulkHandleNode(node, "Prefix expression `$node` unhandled.");
   }
 
   @override
-  R visitClassTypeLiteralPrefix(
-      Send node,
-      TypeConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePrefix(node);
-  }
-
-  @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return bulkHandlePrefix(node);
   }
 
   @override
-  R visitDynamicTypeLiteralPrefix(
-      Send node,
-      TypeConstantExpression constant,
-      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 123 matching lines @@
 
   @override
   R visitTopLevelMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node);
   }
-
-  @override
-  R visitTypeVariableTypeLiteralPrefix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePrefix(node);
-  }
-
-  @override
-  R visitTypedefTypeLiteralPrefix(
-      Send node,
-      TypeConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePrefix(node);
-  }
 }
 
 /// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXPostfix`
 /// methods.
 abstract class PostfixBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
   R bulkHandlePostfix(Send node) {
     return bulkHandleNode(node, "Postfix expression `$node` unhandled.");
   }
 
   @override
-  R visitClassTypeLiteralPostfix(
-      Send node,
-      TypeConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePostfix(node);
-  }
-
-  @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return bulkHandlePostfix(node);
   }
 
   @override
-  R visitDynamicTypeLiteralPostfix(
-      Send node,
-      TypeConstantExpression constant,
-      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 123 matching lines @@
 
   @override
   R visitTopLevelMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node);
   }
-
-  @override
-  R visitTypeVariableTypeLiteralPostfix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePostfix(node);
-  }
-
-  @override
-  R visitTypedefTypeLiteralPostfix(
-      Send node,
-      TypeConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandlePostfix(node);
-  }
 }
 
 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `xCompound`
 /// methods.
 abstract class CompoundBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
   R bulkHandleCompound(Send node) {
     return bulkHandleNode(node, "Compound assignment `$node` unhandled.");
   }
 
   @override
-  R visitClassTypeLiteralCompound(
-      Send node,
-      TypeConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleCompound(node);
-  }
-
-  @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
     return bulkHandleCompound(node);
   }
 
   @override
-  R visitDynamicTypeLiteralCompound(
-      Send node,
-      TypeConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleCompound(node);
-  }
-
-  @override
   R visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleCompound(node);
   }
 
   @override
@@ skipping 127 matching lines @@
   @override
   R visitTopLevelMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleCompound(node);
   }
-
-  @override
-  R visitTypeVariableTypeLiteralCompound(
-      Send node,
-      TypeVariableElement element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleCompound(node);
-  }
-
-  @override
-  R visitTypedefTypeLiteralCompound(
-      Send node,
-      TypeConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleCompound(node);
-  }
 }
 
 /// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXInvoke`
 /// methods.
 abstract class InvokeBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
@@ skipping 478 matching lines @@
   @override
   R visitTopLevelSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
     return bulkHandleSet(node);
   }
 }
 
-/// Mixin that implements all `visitXIndexSet` methods of [SemanticSendVisitor] by
-/// delegating to a bulk handler.
+/// Mixin that implements all `visitXIndexSet` methods of [SemanticSendVisitor]
+/// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXIndexSet`
 /// methods.
 abstract class IndexSetBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
   R bulkHandleIndexSet(Send node) {
     return bulkHandleNode(node, "Index set expression `$node` unhandled.");
   }
 
   @override
   R visitCompoundIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleIndexSet(node);
   }
 
   @override
   R visitIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       Node rhs,
       A arg) {
     return bulkHandleIndexSet(node);
   }
 
   @override
   R visitSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleIndexSet(node);
   }
 
   @override
   R visitSuperIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg) {
     return bulkHandleIndexSet(node);
   }
 }
 
 /// Mixin that implements all binary visitor methods in [SemanticSendVisitor] by
 /// delegating to a bulk handler.
@@ skipping 29 matching lines @@
   @override
   R visitNotEquals(
       Send node,
       Node left,
       Node right,
       A arg) {
     return bulkHandleBinary(node);
   }
 
   @override
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      A arg) {
+    return bulkHandleBinary(node);
+  }
+
+  @override
   R visitSuperBinary(
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
     return bulkHandleBinary(node);
   }
 
   @override
   R visitSuperEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
     return bulkHandleBinary(node);
   }
 
   @override
   R visitSuperNotEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
     return bulkHandleBinary(node);
   }
+
+  @override
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
+      A arg) {
+    return bulkHandleBinary(node);
+  }
 }
 
 /// Mixin that implements all unary visitor methods in [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all unary visitor
 /// methods.
 abstract class UnaryBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
   R bulkHandleNode(Node node, String message);
 
@@ skipping 104 matching lines @@
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
     return bulkHandleSuper(node);
   }
 
   @override
   R visitSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleSuper(node);
   }
 
   @override
@@ skipping 186 matching lines @@
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandleSuper(node);
   }
 
   @override
   R visitSuperIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg) {
     return bulkHandleSuper(node);
   }
 
   @override
   R visitSuperMethodGet(
       Send node,
@@ skipping 442 matching lines @@
       Node left,
       BinaryOperator operator,
       Node right,
       A arg) {
     apply(left, arg);
     apply(right, arg);
     return null;
   }
 
   @override
-  R visitClassTypeLiteralCompound(
+  R errorClassTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitClassTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
   R visitClassTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitClassTypeLiteralPostfix(
+  R errorClassTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitClassTypeLiteralPrefix(
+  R errorClassTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
   R visitCompoundIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(receiver, arg);
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
@@ skipping 82 matching lines @@
       SendSet node,
       Node receiver,
       Selector selector,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitDynamicTypeLiteralCompound(
+  R errorDynamicTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitDynamicTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
   R visitDynamicTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitDynamicTypeLiteralPostfix(
+  R errorDynamicTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitDynamicTypeLiteralPrefix(
+  R errorDynamicTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
   R visitEquals(
       Send node,
@@ skipping 11 matching lines @@
       Node expression,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(expression, arg);
     apply(arguments, arg);
     return null;
   }
 
   @override
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
+  }
+
+  @override
   R visitIndexSet(
-      Send node,
+      SendSet node,
       Node receiver,
       Node index,
       Node rhs,
       A arg) {
     apply(receiver, arg);
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
@@ skipping 370 matching lines @@
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
     apply(argument, arg);
     return null;
   }
 
   @override
   R visitSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
@@ skipping 194 matching lines @@
   R visitSuperGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
   R visitSuperIndexSet(
-      Send node,
+      SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
@@ skipping 315 matching lines @@
   R visitTopLevelSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTypeVariableTypeLiteralCompound(
+  R errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTypeVariableTypeLiteralGet(
       Send node,
       TypeVariableElement element,
       A arg) {
     return null;
   }
 
   @override
   R visitTypeVariableTypeLiteralInvoke(
       Send node,
       TypeVariableElement element,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitTypeVariableTypeLiteralPostfix(
+  R errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitTypeVariableTypeLiteralPrefix(
+  R errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitTypedefTypeLiteralCompound(
+  R errorTypedefTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTypedefTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
   R visitTypedefTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitTypedefTypeLiteralPostfix(
+  R errorTypedefTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitTypedefTypeLiteralPrefix(
+  R errorTypedefTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
   R visitUnary(
       Send node,
@@ skipping 91 matching lines @@
       Node index,
       Node rhs,
       A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R errorUnresolvedSuperCompoundIndexSet(
-      Send node,
+      SendSet node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
@@ skipping 62 matching lines @@
       visitParameters(node.parameters);
     }
     if (node.initializers != null) {
       visitInitializers(node.initializers);
     }
     if (node.body != null) {
       apply(node.body, null);
     }
     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> {
+  R handleStaticFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  R handleStaticFieldGet(
+      Send node,
+      FieldElement field,
+      A arg);
+
+  R handleStaticFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R handleStaticFieldPostfixPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleStaticFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
+      A arg);
+
+  R handleStaticFunctionGet(
+      Send node,
+      MethodElement function,
+      A arg);
+
+  R handleStaticFunctionInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R handleStaticGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg);
+
+  R handleStaticGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R handleStaticGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  R handleStaticGetterSetterPostfixPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleStaticMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  R handleStaticMethodSetterPostfixPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleStaticSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
+      A arg);
+
+  @override
+  R visitStaticFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticFieldCompound(node, field, operator, rhs, arg);
+  }
+
+  @override
+  R visitStaticFieldGet(
+      Send node,
+      FieldElement field,
+      A arg) {
+    return handleStaticFieldGet(node, field, arg);
+  }
+
+  @override
+  R visitStaticFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticFieldInvoke(node, field, arguments, selector, arg);
+  }
+
+  @override
+  R visitStaticFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticFieldPostfixPrefix(
+        node, field, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitStaticFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticFieldPostfixPrefix(
+        node, field, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitStaticFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
+      A arg) {
+    return handleStaticFieldSet(node, field, rhs, arg);
+  }
+
+  @override
+  R visitStaticFunctionGet(
+      Send node,
+      MethodElement function,
+      A arg) {
+    return handleStaticFunctionGet(node, function, arg);
+  }
+
+  @override
+  R visitStaticFunctionInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticFunctionInvoke(node, function, arguments, selector, arg);
+  }
+
+  @override
+  R visitStaticGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg) {
+    return handleStaticGetterGet(node, getter, arg);
+  }
+
+  @override
+  R visitStaticGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticGetterInvoke(node, getter, arguments, selector, arg);
+  }
+
+  @override
+  R visitStaticGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticGetterSetterCompound(
+        node, getter, setter, operator, rhs, arg);
+  }
+
+  @override
+  R visitStaticGetterSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitStaticGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitStaticMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticMethodSetterCompound(
+        node, method, setter, operator, rhs, arg);
+  }
+
+  @override
+  R visitStaticMethodSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticMethodSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitStaticMethodSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticMethodSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitStaticSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
+      A arg) {
+    return handleStaticSetterSet(node, setter, rhs, arg);
+  }
+
+  @override
+  R visitTopLevelFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticFieldCompound(node, field, operator, rhs, arg);
+  }
+
+  @override
+  R visitTopLevelFieldGet(
+      Send node,
+      FieldElement field,
+      A arg) {
+    return handleStaticFieldGet(node, field, arg);
+  }
+
+  @override
+  R visitTopLevelFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticFieldInvoke(node, field, arguments, selector, arg);
+  }
+
+  @override
+  R visitTopLevelFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticFieldPostfixPrefix(
+        node, field, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitTopLevelFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticFieldPostfixPrefix(
+        node, field, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitTopLevelFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
+      A arg) {
+    return handleStaticFieldSet(node, field, rhs, arg);
+  }
+
+  @override
+  R visitTopLevelFunctionGet(
+      Send node,
+      MethodElement function,
+      A arg) {
+    return handleStaticFunctionGet(node, function, arg);
+  }
+
+  @override
+  R visitTopLevelFunctionInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticFunctionInvoke(node, function, arguments, selector, arg);
+  }
+
+  @override
+  R visitTopLevelGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg) {
+    return handleStaticGetterGet(node, getter, arg);
+  }
+
+  @override
+  R visitTopLevelGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleStaticGetterInvoke(node, getter, arguments, selector, arg);
+  }
+
+  @override
+  R visitTopLevelGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticGetterSetterCompound(
+        node, getter, setter, operator, rhs, arg);
+  }
+
+  @override
+  R visitTopLevelGetterSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitTopLevelGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitTopLevelMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticMethodSetterCompound(
+        node, method, setter, operator, rhs, arg);
+  }
+
+  @override
+  R visitTopLevelMethodSetterPostfix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticMethodSetterPostfixPrefix(
+        node, method, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitTopLevelMethodSetterPrefix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticMethodSetterPostfixPrefix(
+        node, method, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitTopLevelSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
+      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> {
+  R handleLocalCompound(
+      Send node,
+      LocalElement element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  R handleLocalGet(
+      Send node,
+      LocalElement element,
+      A arg);
+
+  R handleLocalInvoke(
+      Send node,
+      LocalElement element,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R handleLocalPostfixPrefix(
+      Send node,
+      LocalElement element,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleLocalSet(
+      SendSet node,
+      LocalElement element,
+      Node rhs,
+      A arg);
+
+  @override
+  R visitLocalFunctionGet(
+      Send node,
+      LocalFunctionElement function,
+      A arg) {
+    return handleLocalGet(node, function, arg);
+  }
+
+  @override
+  R visitLocalFunctionInvoke(
+      Send node,
+      LocalFunctionElement function,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleLocalInvoke(node, function, arguments, selector, arg);
+  }
+
+  @override
+  R visitLocalVariableCompound(
+      Send node,
+      LocalVariableElement variable,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleLocalCompound(node, variable, operator, rhs, arg);
+  }
+
+  @override
+  R visitLocalVariableGet(
+      Send node,
+      LocalVariableElement variable,
+      A arg) {
+    return handleLocalGet(node, variable, arg);
+  }
+
+  @override
+  R visitLocalVariableInvoke(
+      Send node,
+      LocalVariableElement variable,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleLocalInvoke(node, variable, arguments, selector, arg);
+  }
+
+  @override
+  R visitLocalVariablePostfix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg) {
+    return handleLocalPostfixPrefix(
+        node, variable, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitLocalVariablePrefix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg) {
+    return handleLocalPostfixPrefix(
+        node, variable, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitLocalVariableSet(
+      SendSet node,
+      LocalVariableElement variable,
+      Node rhs,
+      A arg) {
+    return handleLocalSet(node, variable, rhs, arg);
+  }
+
+  @override
+  R visitParameterCompound(
+      Send node,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleLocalCompound(node, parameter, operator, rhs, arg);
+  }
+
+  @override
+  R visitParameterGet(
+      Send node,
+      ParameterElement parameter,
+      A arg) {
+    return handleLocalGet(node, parameter, arg);
+  }
+
+  @override
+  R visitParameterInvoke(
+      Send node,
+      ParameterElement parameter,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleLocalInvoke(node, parameter, arguments, selector, arg);
+  }
+
+  @override
+  R visitParameterPostfix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return handleLocalPostfixPrefix(
+        node, parameter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitParameterPrefix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return handleLocalPostfixPrefix(
+        node, parameter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitParameterSet(
+      SendSet node,
+      ParameterElement parameter,
+      Node rhs,
+      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> {
+  R handleConstantGet(
+      Send node,
+      ConstantExpression constant,
+      A arg);
+
+  R handleConstantInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  @override
+  R visitClassTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitClassTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, selector, arg);
+  }
+
+  @override
+  R visitConstantGet(
+      Send node,
+      ConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitConstantInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, selector, arg);
+  }
+
+  @override
+  R visitDynamicTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitDynamicTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, selector, arg);
+  }
+
+  @override
+  R visitTypedefTypeLiteralGet(
+      Send node,
+      TypeConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitTypedefTypeLiteralInvoke(
+      Send node,
+      TypeConstantExpression constant,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    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> {
+  R handleDynamicCompound(
+      Send node,
+      Node receiver,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg);
+
+  R handleDynamicGet(
+      Send node,
+      Node receiver,
+      Selector selector,
+      A arg);
+
+  R handleDynamicInvoke(
+      Send node,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      A arg);
+
+  R handleDynamicPostfixPrefix(
+      Send node,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg,
+      {bool isPrefix});
+
+  R handleDynamicSet(
+      SendSet node,
+      Node receiver,
+      Selector selector,
+      Node rhs,
+      A arg);
+
+  @override
+  R visitDynamicPropertyCompound(
+      Send node,
+      Node receiver,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node, receiver, operator, rhs, getterSelector, setterSelector, arg);
+  }
+
+  @override
+  R visitDynamicPropertyGet(
+      Send node,
+      Node receiver,
+      Selector selector,
+      A arg) {
+    return handleDynamicGet(node, receiver, selector, arg);
+  }
+
+  @override
+  R visitDynamicPropertyInvoke(
+      Send node,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleDynamicInvoke(node, receiver, arguments, selector, arg);
+  }
+
+  @override
+  R visitDynamicPropertyPostfix(
+      Send node,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicPostfixPrefix(
+        node, receiver, operator,
+        getterSelector, setterSelector, arg, isPrefix: false);
+  }
+
+  @override
+  R visitDynamicPropertyPrefix(
+      Send node,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicPostfixPrefix(
+        node, receiver, operator,
+        getterSelector, setterSelector, arg, isPrefix: true);
+  }
+
+  @override
+  R visitDynamicPropertySet(
+      SendSet node,
+      Node receiver,
+      Selector selector,
+      Node rhs,
+      A arg) {
+    return handleDynamicSet(node, receiver, selector, rhs, arg);
+  }
+
+  @override
+  R visitThisPropertyCompound(
+      Send node,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node, null, operator, rhs, getterSelector, setterSelector, arg);
+  }
+
+  @override
+  R visitThisPropertyGet(
+      Send node,
+      Selector selector,
+      A arg) {
+    return handleDynamicGet(node, null, selector, arg);
+  }
+
+  @override
+  R visitThisPropertyInvoke(
+      Send node,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    return handleDynamicInvoke(node, null, arguments, selector, arg);
+  }
+
+  @override
+  R visitThisPropertyPostfix(
+      Send node,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicPostfixPrefix(
+        node, null, operator,
+        getterSelector, setterSelector, arg, isPrefix: false);
+  }
+
+  @override
+  R visitThisPropertyPrefix(
+      Send node,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicPostfixPrefix(
+        node, null, operator,
+        getterSelector, setterSelector, arg, isPrefix: true);
+  }
+
+  @override
+  R visitThisPropertySet(
+      SendSet node,
+      Selector selector,
+      Node rhs,
+      A arg) {
+    return handleDynamicSet(node, null, selector, rhs, arg);
+  }
+}
+
+/// 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> {
+  R handleSuperFieldFieldPostfixPrefix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleSuperFieldSetterPostfixPrefix(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleSuperGetterFieldPostfixPrefix(
+      Send node,
+      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleSuperGetterSetterPostfixPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg,
+      {bool isPrefix});
+
+  R handleSuperMethodSetterPostfixPrefix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      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);
+  }
+
+  @override
+  R visitSuperFieldFieldPrefix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperFieldFieldPostfixPrefix(
+        node, readField, writtenField, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitSuperFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperFieldFieldPostfixPrefix(
+        node, field, field, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperFieldFieldPostfixPrefix(
+        node, field, field, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitSuperFieldSetterPostfix(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperFieldSetterPostfixPrefix(
+        node, field, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperFieldSetterPrefix(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperFieldSetterPostfixPrefix(
+        node, field, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitSuperGetterFieldPostfix(
+      Send node,
+      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperGetterFieldPostfixPrefix(
+        node, getter, field, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperGetterFieldPrefix(
+      Send node,
+      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperGetterFieldPostfixPrefix(
+        node, getter, field, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitSuperGetterSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperGetterSetterPostfixPrefix(
+        node, getter, setter, operator, arg, isPrefix: true);
+  }
+
+  @override
+  R visitSuperMethodSetterPostfix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperMethodSetterPostfixPrefix(
+        node, method, setter, operator, arg, isPrefix: false);
+  }
+
+  @override
+  R visitSuperMethodSetterPrefix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperMethodSetterPostfixPrefix(
+        node, method, setter, operator, arg, isPrefix: true);
+  }
+}