Refactor handling of compounds.

pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart

Index: pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart
diff --git a/pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart b/pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart
index 7f5b884f315fa3a0aaab8f74beb84d294b915712..e4014a8ab1b3d01d69178675145784dd298ab9e3 100644
--- a/pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart
+++ b/pkg/compiler/lib/src/resolution/semantic_visitor_mixins.dart
@@ -33,34 +33,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorClassTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorClassTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorClassTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorClassTypeLiteralSet(
       SendSet node,
       ConstantExpression constant,
@@ -70,34 +42,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorDynamicTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorDynamicTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorDynamicTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorDynamicTypeLiteralSet(
       SendSet node,
       ConstantExpression constant,
@@ -107,17 +51,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorFinalLocalVariableCompound(
-      Send node,
-      LocalVariableElement
-      variable,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorFinalLocalVariableSet(
       SendSet node,
       LocalVariableElement variable,
@@ -127,16 +60,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorFinalParameterCompound(
-      Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorFinalParameterSet(
       SendSet node,
       ParameterElement parameter,
@@ -146,16 +69,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorFinalStaticFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorFinalStaticFieldSet(
       SendSet node,
       FieldElement field,
@@ -165,16 +78,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorFinalSuperFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorFinalSuperFieldSet(
       SendSet node,
       FieldElement field,
@@ -184,16 +87,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorFinalTopLevelFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorFinalTopLevelFieldSet(
       SendSet node,
       FieldElement field,
@@ -203,34 +96,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorLocalFunctionCompound(
-      Send node,
-      LocalFunctionElement function,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorLocalFunctionPostfix(
-      Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorLocalFunctionPrefix(
-      Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorLocalFunctionSet(
       SendSet node,
       LocalFunctionElement function,
@@ -359,34 +224,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorTypeVariableTypeLiteralCompound(
-      Send node,
-      TypeVariableElement element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorTypeVariableTypeLiteralPostfix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorTypeVariableTypeLiteralPrefix(
-      Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorTypeVariableTypeLiteralSet(
       SendSet node,
       TypeVariableElement element,
@@ -396,34 +233,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorTypedefTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorTypedefTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorTypedefTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorTypedefTypeLiteralSet(
       SendSet node,
       ConstantExpression constant,
@@ -433,34 +242,6 @@ abstract class ErrorBulkMixin<R, A>
   }
 
   @override
-  R errorUnresolvedCompound(
-      Send node,
-      Element element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorUnresolvedPostfix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
-  R errorUnresolvedPrefix(
-      Send node,
-      Element element,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleError(node, arg);
-  }
-
-  @override
   R errorUnresolvedSet(
       Send node,
       Element element,
@@ -698,3059 +479,2922 @@ abstract class PrefixBulkMixin<R, A>
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
-}
-
-/// 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>, BulkHandle<R, A> {
-
-  R bulkHandlePostfix(Send node, A arg) {
-    return bulkHandleNode(node, "Postfix expression `#` unhandled.", arg);
-  }
 
   @override
-  R visitDynamicPropertyPostfix(
+  R visitClassTypeLiteralPrefix(
       Send node,
-      Node receiver,
+      ConstantExpression constant,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitIndexPostfix(
+  R visitDynamicTypeLiteralPrefix(
       Send node,
-      Node receiver,
-      Node index,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitLocalVariablePostfix(
+  R visitLocalFunctionPrefix(
       Send node,
-      LocalVariableElement variable,
+      LocalFunctionElement function,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitParameterPostfix(
+  R visitTypeVariableTypeLiteralPrefix(
       Send node,
-      ParameterElement parameter,
+      TypeVariableElement element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitStaticFieldPostfix(
+  R visitTypedefTypeLiteralPrefix(
       Send node,
-      FieldElement field,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitStaticGetterSetterPostfix(
+  R visitUnresolvedStaticGetterPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitStaticMethodSetterPostfix(
+  R visitUnresolvedTopLevelGetterPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperFieldFieldPostfix(
+  R visitUnresolvedStaticSetterPrefix(
       Send node,
-      FieldElement readField,
-      FieldElement writtenField,
+      MethodElement getter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperFieldPostfix(
+  R visitUnresolvedTopLevelSetterPrefix(
       Send node,
-      FieldElement field,
+      MethodElement getter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPostfix(
+  R visitStaticMethodPrefix(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
+      MethodElement method,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(
+  R visitTopLevelMethodPrefix(
       Send node,
-      FunctionElement getter,
-      FieldElement field,
+      MethodElement method,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPostfix(
+  R visitUnresolvedPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperIndexPostfix(
+  R visitFinalLocalVariablePrefix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
-      Node index,
+      LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPostfix(
+  R visitFinalParameterPrefix(
       Send node,
-      Element element,
-      Node index,
+      ParameterElement parameter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPostfix(
+  R visitStaticFinalFieldPrefix(
       Send node,
-      MethodElement getter,
-      Element element,
-      Node index,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterPostfix(
+  R visitSuperFinalFieldPrefix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitThisPropertyPostfix(
+  R visitSuperMethodPrefix(
       Send node,
+      FunctionElement method,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitTopLevelFieldPostfix(
+  R visitTopLevelFinalFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitTopLevelGetterSetterPostfix(
+  R visitUnresolvedSuperPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitTopLevelMethodSetterPostfix(
+  R visitUnresolvedSuperGetterPrefix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node, arg);
+    return bulkHandlePrefix(node, arg);
+  }
+
+  @override
+  R visitUnresolvedSuperSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePrefix(node, arg);
   }
 }
 
-/// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
+/// Mixin that implements all `visitXPostfix` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for all `xCompound`
+/// Use this mixin to provide a trivial implementation for all `visitXPostfix`
 /// methods.
-abstract class CompoundBulkMixin<R, A>
+abstract class PostfixBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleCompound(Send node, A arg) {
-    return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
+  R bulkHandlePostfix(Send node, A arg) {
+    return bulkHandleNode(node, "Postfix expression `#` unhandled.", arg);
   }
 
   @override
-  R visitDynamicPropertyCompound(
+  R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitLocalVariableCompound(
+  R visitIndexPostfix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node, arg);
+  }
+
+  @override
+  R visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitParameterCompound(
+  R visitParameterPostfix(
       Send node,
       ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticFieldCompound(
+  R visitStaticFieldPostfix(
       Send node,
       FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticGetterSetterCompound(
+  R visitStaticGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticMethodSetterCompound(
+  R visitStaticMethodSetterPostfix(
       Send node,
-      FunctionElement method,
+      FunctionElement getter,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperFieldCompound(
+  R visitSuperFieldFieldPostfix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node, arg);
+  }
+
+  @override
+  R visitSuperFieldPostfix(
       Send node,
       FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterCompound(
+  R visitSuperFieldSetterPostfix(
       Send node,
       FieldElement field,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldCompound(
+  R visitSuperGetterFieldPostfix(
       Send node,
       FunctionElement getter,
       FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterCompound(
+  R visitSuperGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterCompound(
+  R visitSuperIndexPostfix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node, arg);
+  }
+
+  @override
+  R visitUnresolvedSuperGetterIndexPostfix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node, arg);
+  }
+
+  @override
+  R visitUnresolvedSuperSetterIndexPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    return bulkHandlePostfix(node, arg);
+  }
+
+  @override
+  R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitThisPropertyCompound(
+  R visitThisPropertyPostfix(
       Send node,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelFieldCompound(
+  R visitTopLevelFieldPostfix(
       Send node,
       FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelGetterSetterCompound(
+  R visitTopLevelGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelMethodSetterCompound(
+  R visitTopLevelMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleCompound(node, arg);
-  }
-}
-
-/// 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>, BulkHandle<R, A> {
-
-  R bulkHandleInvoke(Send node, A arg) {
-    return bulkHandleNode(node, "Invocation `#` unhandled.", arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitClassTypeLiteralInvoke(
+  R visitClassTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    return bulkHandleInvoke(node, arg);
-  }
-
-  @override
-  R visitDynamicPropertyInvoke(
-      Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitDynamicTypeLiteralInvoke(
+  R visitDynamicTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    return bulkHandleInvoke(node, arg);
-  }
-
-  @override
-  R visitExpressionInvoke(
-      Send node,
-      Node expression,
-      NodeList arguments,
-      Selector selector,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitLocalFunctionInvoke(
+  R visitLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    return bulkHandleInvoke(node, arg);
-  }
-
-  @override
-  R visitLocalVariableInvoke(
-      Send node,
-      LocalVariableElement variable,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    return bulkHandleInvoke(node, arg);
-  }
-
-  @override
-  R visitParameterInvoke(
-      Send node,
-      ParameterElement parameter,
-      NodeList arguments,
-      CallStructure callStructure,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticFieldInvoke(
+  R visitTypeVariableTypeLiteralPostfix(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      TypeVariableElement element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticFunctionInvoke(
+  R visitTypedefTypeLiteralPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticFunctionIncompatibleInvoke(
+  R visitUnresolvedStaticGetterPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticGetterInvoke(
+  R visitUnresolvedTopLevelGetterPostfix(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperFieldInvoke(
+  R visitUnresolvedStaticSetterPostfix(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperGetterInvoke(
+  R visitUnresolvedTopLevelSetterPostfix(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperMethodInvoke(
+  R visitStaticMethodPostfix(
       Send node,
       MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
-  @override
-  R visitSuperMethodIncompatibleInvoke(
+  R visitToplevelMethodPostfix(
       Send node,
       MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitThisInvoke(
+  R visitUnresolvedPostfix(
       Send node,
-      NodeList arguments,
-      CallStructure callStructure,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitThisPropertyInvoke(
+  R visitFinalLocalVariablePostfix(
       Send node,
-      NodeList arguments,
-      Selector selector,
+      LocalVariableElement variable,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelFieldInvoke(
+  R visitFinalParameterPostfix(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      ParameterElement parameter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelFunctionInvoke(
+  R visitStaticFinalFieldPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelFunctionIncompatibleInvoke(
+  R visitSuperFinalFieldPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTopLevelGetterInvoke(
+  R visitSuperMethodPostfix(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement method,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTypeVariableTypeLiteralInvoke(
+  R visitTopLevelFinalFieldPostfix(
       Send node,
-      TypeVariableElement element,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitTypedefTypeLiteralInvoke(
+  R visitTopLevelMethodPostfix(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement method,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitConstantInvoke(
+  R visitUnresolvedSuperPostfix(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedInvoke(
+  R visitUnresolvedSuperGetterPostfix(
       Send node,
       Element element,
-      NodeList arguments,
-      Selector selector,
+      MethodElement setter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperInvoke(
+  R visitUnresolvedSuperSetterPostfix(
       Send node,
-      Element function,
-      NodeList arguments,
-      Selector selector,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleInvoke(node, arg);
+    return bulkHandlePostfix(node, arg);
   }
 }
 
-/// Mixin that implements all `visitXGet` methods of [SemanticSendVisitor] by
-/// delegating to a bulk handler.
+/// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
+/// by delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for all `visitXGet`
+/// Use this mixin to provide a trivial implementation for all `xCompound`
 /// methods.
-abstract class GetBulkMixin<R, A>
+abstract class CompoundBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleGet(Node node, A arg) {
-    return bulkHandleNode(node, "Read `#` unhandled.", arg);
+  R bulkHandleCompound(Send node, A arg) {
+    return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
   }
 
   @override
-  R visitClassTypeLiteralGet(
+  R visitDynamicPropertyCompound(
       Send node,
-      ConstantExpression constant,
+      Node receiver,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitDynamicPropertyGet(
+  R visitLocalVariableCompound(
       Send node,
-      Node receiver,
-      Selector selector,
+      LocalVariableElement variable,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitDynamicTypeLiteralGet(
+  R visitParameterCompound(
       Send node,
-      ConstantExpression constant,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitLocalFunctionGet(
+  R visitStaticFieldCompound(
       Send node,
-      LocalFunctionElement function,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitLocalVariableGet(
+  R visitStaticGetterSetterCompound(
       Send node,
-      LocalVariableElement variable,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitParameterGet(
+  R visitStaticMethodSetterCompound(
       Send node,
-      ParameterElement parameter,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitStaticFieldGet(
+  R visitSuperFieldCompound(
       Send node,
       FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitStaticFunctionGet(
+  R visitSuperFieldSetterCompound(
       Send node,
-      MethodElement function,
+      FieldElement field,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitStaticGetterGet(
+  R visitSuperGetterFieldCompound(
       Send node,
       FunctionElement getter,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperFieldGet(
+  R visitSuperGetterSetterCompound(
       Send node,
-      FieldElement field,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperGetterGet(
+  R visitSuperMethodSetterCompound(
       Send node,
-      FunctionElement getter,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperMethodGet(
+  R visitThisPropertyCompound(
       Send node,
-      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitThisGet(Identifier node, A arg) {
-    return bulkHandleGet(node, arg);
+  R visitTopLevelFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitThisPropertyGet(
+  R visitTopLevelGetterSetterCompound(
       Send node,
-      Selector selector,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTopLevelFieldGet(
+  R visitTopLevelMethodSetterCompound(
       Send node,
-      FieldElement field,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTopLevelFunctionGet(
+  R visitFinalParameterCompound(
       Send node,
-      MethodElement function,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTopLevelGetterGet(
+  R visitClassTypeLiteralCompound(
       Send node,
-      FunctionElement getter,
+      ConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTypeVariableTypeLiteralGet(
+  R visitDynamicTypeLiteralCompound(
       Send node,
-      TypeVariableElement element,
+      ConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTypedefTypeLiteralGet(
+  R visitFinalLocalVariableCompound(
       Send node,
-      ConstantExpression constant,
+      LocalVariableElement
+      variable,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitConstantGet(
+  R visitStaticFinalFieldCompound(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedGet(
+  R visitSuperFinalFieldCompound(
       Send node,
-      Element element,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGet(
+  R visitTopLevelFinalFieldCompound(
       Send node,
-      Element element,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleGet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
-}
-
-/// Mixin that implements all `visitXSet` methods of [SemanticSendVisitor] by
-/// delegating to a bulk handler.
-///
-/// Use this mixin to provide a trivial implementation for all `visitXSet`
-/// methods.
-abstract class SetBulkMixin<R, A>
-    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleSet(Send node, A arg) {
-    return bulkHandleNode(node, "Assignment `#` unhandled.", arg);
+  @override
+  R visitLocalFunctionCompound(
+      Send node,
+      LocalFunctionElement function,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitDynamicPropertySet(
-      SendSet node,
-      Node receiver,
-      Selector selector,
+  R visitTypeVariableTypeLiteralCompound(
+      Send node,
+      TypeVariableElement element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
+  R visitTypedefTypeLiteralCompound(
+      Send node,
+      ConstantExpression constant,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitParameterSet(
-      SendSet node,
-      ParameterElement parameter,
+  R visitUnresolvedStaticGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitStaticFieldSet(
-      SendSet node,
-      FieldElement field,
+  R visitUnresolvedTopLevelGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitStaticSetterSet(
-      SendSet node,
-      FunctionElement setter,
+  R visitUnresolvedStaticSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperFieldSet(
-      SendSet node,
-      FieldElement field,
+  R visitUnresolvedTopLevelSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperSetterSet(
-      SendSet node,
-      FunctionElement setter,
+  R visitStaticMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitThisPropertySet(
-      SendSet node,
-      Selector selector,
+  R visitTopLevelMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
+  R visitUnresolvedCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitTopLevelSetterSet(
-      SendSet node,
-      FunctionElement setter,
+  R visitSuperFieldFieldCompound(
+      Send node, FieldElement readField,
+      FieldElement writtenField,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node, arg);
-  }
-}
-
-/// 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>, BulkHandle<R, A> {
-
-  R bulkHandleIndexSet(Send node, A arg) {
-    return bulkHandleNode(node, "Index set expression `#` unhandled.", arg);
-  }
-
-  @override
-  R visitCompoundIndexSet(
-      SendSet node,
-      Node receiver,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    return bulkHandleIndexSet(node, arg);
-  }
-
-  @override
-  R visitIndexSet(
-      SendSet node,
-      Node receiver,
-      Node index,
-      Node rhs,
-      A arg) {
-    return bulkHandleIndexSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperCompoundIndexSet(
-      SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node index,
+  R visitSuperMethodCompound(
+      Send node,
+      FunctionElement method,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterCompoundIndexSet(
-      SendSet node,
+  R visitUnresolvedSuperCompound(
+      Send node,
       Element element,
-      Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterCompoundIndexSet(
-      SendSet node,
-      MethodElement getter,
-      Element element,
-      Node index,
+  R visitUnresolvedSuperGetterCompound(
+      Send node, Element element,
+      MethodElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node, arg);
-  }
-
-  @override
-  R visitSuperIndexSet(
-      SendSet node,
-      FunctionElement function,
-      Node index,
-      Node rhs,
-      A arg) {
-    return bulkHandleIndexSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperIndexSet(
-      SendSet node,
+  R visitUnresolvedSuperSetterCompound(
+      Send node, MethodElement getter,
       Element element,
-      Node index,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node, arg);
+    return bulkHandleCompound(node, arg);
   }
 }
 
-/// Mixin that implements all binary visitor methods in [SemanticSendVisitor] by
+/// Mixin that implements all `visitXInvoke` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for all binary visitor
+/// Use this mixin to provide a trivial implementation for all `visitXInvoke`
 /// methods.
-abstract class BinaryBulkMixin<R, A>
+abstract class InvokeBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleBinary(Send node, A arg) {
-    return bulkHandleNode(node, "Binary expression `#` unhandled.", arg);
+  R bulkHandleInvoke(Send node, A arg) {
+    return bulkHandleNode(node, "Invocation `#` unhandled.", arg);
   }
 
   @override
-  R visitBinary(
+  R visitClassTypeLiteralInvoke(
       Send node,
-      Node left,
-      BinaryOperator operator,
-      Node right,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitEquals(
+  R visitDynamicPropertyInvoke(
       Send node,
-      Node left,
-      Node right,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitNotEquals(
+  R visitDynamicTypeLiteralInvoke(
       Send node,
-      Node left,
-      Node right,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitIndex(
+  R visitExpressionInvoke(
       Send node,
-      Node receiver,
-      Node index,
+      Node expression,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperBinary(
+  R visitLocalFunctionInvoke(
       Send node,
-      FunctionElement function,
-      BinaryOperator operator,
-      Node argument,
+      LocalFunctionElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperEquals(
+  R visitLocalVariableInvoke(
       Send node,
-      FunctionElement function,
-      Node argument,
+      LocalVariableElement variable,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperNotEquals(
+  R visitParameterInvoke(
       Send node,
-      FunctionElement function,
-      Node argument,
+      ParameterElement parameter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperIndex(
+  R visitStaticFieldInvoke(
       Send node,
-      FunctionElement function,
-      Node index,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperBinary(
+  R visitStaticFunctionInvoke(
       Send node,
-      FunctionElement function,
-      BinaryOperator operator,
-      Node argument,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperInvoke(
+  R visitStaticFunctionIncompatibleInvoke(
       Send node,
-      Element function,
+      MethodElement function,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperIndex(
+  R visitStaticGetterInvoke(
       Send node,
-      FunctionElement function,
-      Node index,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleBinary(node, arg);
-  }
-}
-
-/// 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>, BulkHandle<R, A> {
-
-  R bulkHandleUnary(Send node, A arg) {
-    return bulkHandleNode(node, "Unary expression `#` unhandled.", arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitNot(
+  R visitSuperFieldInvoke(
       Send node,
-      Node expression,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleUnary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperUnary(
+  R visitSuperGetterInvoke(
       Send node,
-      UnaryOperator operator,
-      FunctionElement function,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleUnary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitUnary(
+  R visitSuperMethodInvoke(
       Send node,
-      UnaryOperator operator,
-      Node expression,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleUnary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperUnary(
+  R visitSuperMethodIncompatibleInvoke(
       Send node,
-      UnaryOperator operator,
-      FunctionElement function,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleUnary(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
-}
-
-/// Mixin that implements all purely structural visitor methods in
-/// [SemanticSendVisitor] by delegating to a bulk handler.
-///
-/// Use this mixin to provide a trivial implementation for all purely structural
-/// visitor methods.
-abstract class BaseBulkMixin<R, A>
-    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   @override
-  R visitAs(
+  R visitThisInvoke(
       Send node,
-      Node expression,
-      DartType type,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleNode(node, 'As cast `#` unhandled.', arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitAssert(
+  R visitThisPropertyInvoke(
       Send node,
-      Node expression,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleNode(node, 'Assert `#` unhandled.', arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitIs(
+  R visitTopLevelFieldInvoke(
       Send node,
-      Node expression,
-      DartType type,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleNode(node, 'Is test `#` unhandled.', arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitIsNot(
+  R visitTopLevelFunctionInvoke(
       Send node,
-      Node expression,
-      DartType type,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleNode(node, 'Is not test `#` unhandled.', arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitLogicalAnd(
+  R visitTopLevelFunctionIncompatibleInvoke(
       Send node,
-      Node left,
-      Node right,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleNode(node, 'Lazy and `#` unhandled.', arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitLogicalOr(
+  R visitTopLevelGetterInvoke(
       Send node,
-      Node left,
-      Node right,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleNode(node, 'Lazy or `#` unhandled.', arg);
-  }
-}
-
-/// Mixin that implements all visitor methods for `super` calls in
-/// [SemanticSendVisitor] by delegating to a bulk handler.
-///
-/// Use this mixin to provide a trivial implementation for `super` calls
-/// visitor methods.
-abstract class SuperBulkMixin<R, A>
-    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
-
-  R bulkHandleSuper(Send node, A arg) {
-    return bulkHandleNode(node, "Super call `#` unhandled.", arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperBinary(
+  R visitTypeVariableTypeLiteralInvoke(
       Send node,
-      FunctionElement function,
-      BinaryOperator operator,
-      Node argument,
+      TypeVariableElement element,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperCompoundIndexSet(
-      SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
+  R visitTypedefTypeLiteralInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperEquals(
+  R visitConstantInvoke(
       Send node,
-      FunctionElement function,
-      Node argument,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperFieldCompound(
+  R visitUnresolvedInvoke(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      Element element,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperFieldFieldPostfix(
+  R visitUnresolvedSuperInvoke(
       Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
+      Element function,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleInvoke(node, arg);
   }
+}
 
-  @override
-  R visitSuperFieldFieldPrefix(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
-      A arg) {
-    return bulkHandleSuper(node, arg);
+/// Mixin that implements all `visitXGet` methods of [SemanticSendVisitor] by
+/// delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for all `visitXGet`
+/// methods.
+abstract class GetBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleGet(Node node, A arg) {
+    return bulkHandleNode(node, "Read `#` unhandled.", arg);
   }
 
   @override
-  R visitSuperFieldGet(
+  R visitClassTypeLiteralGet(
       Send node,
-      FieldElement field,
+      ConstantExpression constant,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldInvoke(
+  R visitDynamicPropertyGet(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      Node receiver,
+      Selector selector,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldPostfix(
+  R visitDynamicTypeLiteralGet(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      ConstantExpression constant,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldPrefix(
+  R visitLocalFunctionGet(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      LocalFunctionElement function,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitLocalVariableGet(
+      Send node,
+      LocalVariableElement variable,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterCompound(
+  R visitParameterGet(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      ParameterElement parameter,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPostfix(
+  R visitStaticFieldGet(
       Send node,
       FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPrefix(
+  R visitStaticFunctionGet(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
+      MethodElement function,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldCompound(
+  R visitStaticGetterGet(
       Send node,
       FunctionElement getter,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(
+  R visitSuperFieldGet(
       Send node,
-      FunctionElement getter,
       FieldElement field,
-      IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPrefix(
+  R visitSuperGetterGet(
       Send node,
       FunctionElement getter,
-      FieldElement field,
-      IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterGet(
+  R visitSuperMethodGet(
       Send node,
-      FunctionElement getter,
+      MethodElement method,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterInvoke(
-      Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    return bulkHandleSuper(node, arg);
+  R visitThisGet(Identifier node, A arg) {
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterCompound(
+  R visitThisPropertyGet(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      Selector selector,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPostfix(
+  R visitTopLevelFieldGet(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
+      FieldElement field,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPrefix(
+  R visitTopLevelFunctionGet(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
+      MethodElement function,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperIndexSet(
-      SendSet node,
-      FunctionElement function,
-      Node index,
-      Node rhs,
+  R visitTopLevelGetterGet(
+      Send node,
+      FunctionElement getter,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperMethodGet(
+  R visitTypeVariableTypeLiteralGet(
       Send node,
-      MethodElement method,
+      TypeVariableElement element,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperMethodInvoke(
+  R visitTypedefTypeLiteralGet(
       Send node,
-      MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
+      ConstantExpression constant,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperMethodIncompatibleInvoke(
+  R visitConstantGet(
       Send node,
-      MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
+      ConstantExpression constant,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterCompound(
+  R visitUnresolvedGet(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      Element element,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterPostfix(
+  R visitUnresolvedSuperGet(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
+      Element element,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleGet(node, arg);
+  }
+}
+
+/// Mixin that implements all `visitXSet` methods of [SemanticSendVisitor] by
+/// delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for all `visitXSet`
+/// methods.
+abstract class SetBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleSet(Send node, A arg) {
+    return bulkHandleNode(node, "Assignment `#` unhandled.", arg);
   }
 
   @override
-  R visitSuperMethodSetterPrefix(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
+  R visitDynamicPropertySet(
+      SendSet node,
+      Node receiver,
+      Selector selector,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitSuperNotEquals(
-      Send node,
-      FunctionElement function,
-      Node argument,
+  R visitLocalVariableSet(
+      SendSet node,
+      LocalVariableElement variable,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitSuperSetterSet(
+  R visitParameterSet(
       SendSet node,
-      FunctionElement setter,
+      ParameterElement parameter,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitSuperUnary(
-      Send node,
-      UnaryOperator operator,
-      FunctionElement function,
+  R visitStaticFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperBinary(
-      Send node,
-      Element element,
-      BinaryOperator operator,
-      Node argument,
+  R visitStaticSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGet(
-      Send node,
-      Element element,
+  R visitSuperFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperInvoke(
-      Send node,
-      Element function,
-      NodeList arguments,
+  R visitSuperSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
+      A arg) {
+    return bulkHandleSet(node, arg);
+  }
+
+  @override
+  R visitThisPropertySet(
+      SendSet node,
       Selector selector,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperIndex(
-      Send node,
-      Element function,
-      Node index,
+  R visitTopLevelFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperUnary(
-      Send node,
-      UnaryOperator operator,
-      Element element,
+  R visitTopLevelSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
       A arg) {
-    return bulkHandleSuper(node, arg);
+    return bulkHandleSet(node, arg);
   }
 }
 
-abstract class NewBulkMixin<R, A>
+/// 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>, BulkHandle<R, A> {
 
-  R bulkHandleNew(NewExpression node, A arg) {
-    return bulkHandleNode(
-        node, "Constructor invocation `#` unhandled.", arg);
+  R bulkHandleIndexSet(Send node, A arg) {
+    return bulkHandleNode(node, "Index set expression `#` unhandled.", arg);
   }
 
   @override
-  R visitAbstractClassConstructorInvoke(
-      NewExpression node,
-      ConstructorElement element,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitCompoundIndexSet(
+      SendSet node,
+      Node receiver,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
   @override
-  R visitConstConstructorInvoke(
-      NewExpression node,
-      ConstructedConstantExpression constant,
+  R visitIndexSet(
+      SendSet node,
+      Node receiver,
+      Node index,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
-  R visitGenerativeConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  @override
+  R visitSuperCompoundIndexSet(
+      SendSet node,
+      FunctionElement getter,
+      FunctionElement setter,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
-  R visitRedirectingGenerativeConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  @override
+  R visitUnresolvedSuperGetterCompoundIndexSet(
+      SendSet node,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
-  R visitFactoryConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  @override
+  R visitUnresolvedSuperSetterCompoundIndexSet(
+      SendSet node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
-  R visitRedirectingFactoryConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
-      NodeList arguments,
-      CallStructure callStructure,
+  @override
+  R visitSuperIndexSet(
+      SendSet node,
+      FunctionElement function,
+      Node index,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
 
   @override
-  R visitUnresolvedClassConstructorInvoke(
-      NewExpression node,
+  R visitUnresolvedSuperIndexSet(
+      SendSet node,
       Element element,
-      DartType type,
-      NodeList arguments,
-      Selector selector,
+      Node index,
+      Node rhs,
       A arg) {
-    return bulkHandleNew(node, arg);
+    return bulkHandleIndexSet(node, arg);
   }
+}
 
-  @override
-  R visitUnresolvedConstructorInvoke(
-      NewExpression node,
-      Element constructor,
-      DartType type,
-      NodeList arguments,
-      Selector selector,
-      A arg) {
-    return bulkHandleNew(node, arg);
+/// Mixin that implements all binary visitor methods in [SemanticSendVisitor] by
+/// delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for all binary visitor
+/// methods.
+abstract class BinaryBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleBinary(Send node, A arg) {
+    return bulkHandleNode(node, "Binary expression `#` unhandled.", arg);
   }
 
   @override
-  R visitUnresolvedRedirectingFactoryConstructorInvoke(
-       NewExpression node,
-       ConstructorElement constructor,
-       InterfaceType type,
-       NodeList arguments,
-       CallStructure callStructure,
-       A arg) {
-    return bulkHandleNew(node, arg);
+  R visitBinary(
+      Send node,
+      Node left,
+      BinaryOperator operator,
+      Node right,
+      A arg) {
+    return bulkHandleBinary(node, arg);
   }
-}
 
-/// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins.
-///
-/// This class is useful in itself, but shows how to use the `BulkX` mixins and
-/// tests that the union of the `BulkX` mixins implement all `visit` and `error`
-/// methods of [SemanticSendVisitor].
-class BulkSendVisitor<R, A> extends SemanticSendVisitor<R, A>
-    with GetBulkMixin<R, A>,
-         SetBulkMixin<R, A>,
-         ErrorBulkMixin<R, A>,
-         InvokeBulkMixin<R, A>,
-         IndexSetBulkMixin<R, A>,
-         CompoundBulkMixin<R, A>,
-         UnaryBulkMixin<R, A>,
-         BaseBulkMixin<R, A>,
-         BinaryBulkMixin<R, A>,
-         PrefixBulkMixin<R, A>,
-         PostfixBulkMixin<R, A>,
-         NewBulkMixin<R, A> {
   @override
-  R apply(Node node, A arg) {
-    throw new UnimplementedError("BulkSendVisitor.apply unimplemented");
+  R visitEquals(
+      Send node,
+      Node left,
+      Node right,
+      A arg) {
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R bulkHandleNode(Node node, String message, A arg) {
-    throw new UnimplementedError(
-        "BulkSendVisitor.bulkHandleNode unimplemented");
+  R visitNotEquals(
+      Send node,
+      Node left,
+      Node right,
+      A arg) {
+    return bulkHandleBinary(node, arg);
   }
-}
 
-/// Mixin that implements all `visitXParameterDecl` and
-/// `visitXInitializingFormalDecl` methods of [SemanticDeclarationVisitor]
-/// by delegating to a bulk handler.
-///
-/// Use this mixin to provide a trivial implementation for these methods.
-abstract class ParameterBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+  @override
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      A arg) {
+    return bulkHandleBinary(node, arg);
+  }
 
-  R bulkHandleParameterDeclaration(VariableDefinitions node, A arg) {
-    return bulkHandleNode(
-        node, "Parameter declaration `#` unhandled.", arg);
+  @override
+  R visitSuperBinary(
+      Send node,
+      FunctionElement function,
+      BinaryOperator operator,
+      Node argument,
+      A arg) {
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement parameter,
-      int index,
+  R visitSuperEquals(
+      Send node,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitNamedInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement parameter,
-      ConstantExpression defaultValue,
+  R visitSuperNotEquals(
+      Send node,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitNamedParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      ConstantExpression defaultValue,
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitOptionalInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement parameter,
-      ConstantExpression defaultValue,
-      int index,
+  R visitUnresolvedSuperBinary(
+      Send node,
+      FunctionElement function,
+      BinaryOperator operator,
+      Node argument,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitOptionalParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      ConstantExpression defaultValue,
-      int index,
+  R visitUnresolvedSuperInvoke(
+      Send node,
+      Element function,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      int index,
+  R visitUnresolvedSuperIndex(
+      Send node,
+      FunctionElement function,
+      Node index,
       A arg) {
-    return bulkHandleParameterDeclaration(node, arg);
+    return bulkHandleBinary(node, arg);
   }
 }
 
-/// Mixin that implements all `visitXConstructorDecl` methods of
-/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+/// Mixin that implements all unary visitor methods in [SemanticSendVisitor] by
+/// delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for these methods.
-abstract class ConstructorBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+/// Use this mixin to provide a trivial implementation for all unary visitor
+/// methods.
+abstract class UnaryBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleConstructorDeclaration(FunctionExpression node, A arg) {
-    return bulkHandleNode(
-        node, "Constructor declaration `#` unhandled.", arg);
+  R bulkHandleUnary(Send node, A arg) {
+    return bulkHandleNode(node, "Unary expression `#` unhandled.", arg);
   }
 
   @override
-  R visitFactoryConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      Node body,
+  R visitNot(
+      Send node,
+      Node expression,
       A arg) {
-    return bulkHandleConstructorDeclaration(node, arg);
+    return bulkHandleUnary(node, arg);
   }
 
   @override
-  R visitGenerativeConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      NodeList initializers,
-      Node body,
+  R visitSuperUnary(
+      Send node,
+      UnaryOperator operator,
+      FunctionElement function,
       A arg) {
-    return bulkHandleConstructorDeclaration(node, arg);
+    return bulkHandleUnary(node, arg);
   }
 
   @override
-  R visitRedirectingFactoryConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      InterfaceType redirectionType,
-      ConstructorElement redirectionTarget,
+  R visitUnary(
+      Send node,
+      UnaryOperator operator,
+      Node expression,
       A arg) {
-    return bulkHandleConstructorDeclaration(node, arg);
+    return bulkHandleUnary(node, arg);
   }
 
   @override
-  R visitRedirectingGenerativeConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      NodeList initializers,
+  R visitUnresolvedSuperUnary(
+      Send node,
+      UnaryOperator operator,
+      FunctionElement function,
       A arg) {
-    return bulkHandleConstructorDeclaration(node, arg);
+    return bulkHandleUnary(node, arg);
   }
 }
 
-/// Mixin that implements all constructor initializer visitor methods of
-/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+/// Mixin that implements all purely structural visitor methods in
+/// [SemanticSendVisitor] by delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for these methods.
-abstract class InitializerBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+/// Use this mixin to provide a trivial implementation for all purely structural
+/// visitor methods.
+abstract class BaseBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleInitializer(Send node, A arg) {
-    return bulkHandleNode(
-        node, "Initializer `#` unhandled.", arg);
+  @override
+  R visitAs(
+      Send node,
+      Node expression,
+      DartType type,
+      A arg) {
+    return bulkHandleNode(node, 'As cast `#` unhandled.', arg);
   }
 
   @override
-  R errorUnresolvedFieldInitializer(
-      SendSet node,
-      Element element,
-      Node initializer,
+  R visitAssert(
+      Send node,
+      Node expression,
       A arg) {
-    return bulkHandleInitializer(node, arg);
+    return bulkHandleNode(node, 'Assert `#` unhandled.', arg);
   }
 
   @override
-  R errorUnresolvedSuperConstructorInvoke(
+  R visitIs(
       Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
+      Node expression,
+      DartType type,
       A arg) {
-    return bulkHandleInitializer(node, arg);
+    return bulkHandleNode(node, 'Is test `#` unhandled.', arg);
   }
 
   @override
-  R errorUnresolvedThisConstructorInvoke(
+  R visitIsNot(
       Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
-      A arg) {
-    return bulkHandleInitializer(node, arg);
-  }
-
-  @override
-  R visitFieldInitializer(
-      SendSet node,
-      FieldElement field,
-      Node initializer,
+      Node expression,
+      DartType type,
       A arg) {
-    return bulkHandleInitializer(node, arg);
+    return bulkHandleNode(node, 'Is not test `#` unhandled.', arg);
   }
 
   @override
-  R visitSuperConstructorInvoke(
+  R visitLogicalAnd(
       Send node,
-      ConstructorElement superConstructor,
-      InterfaceType type,
-      NodeList arguments,
-      Selector selector,
+      Node left,
+      Node right,
       A arg) {
-    return bulkHandleInitializer(node, arg);
+    return bulkHandleNode(node, 'Lazy and `#` unhandled.', arg);
   }
 
   @override
-  R visitThisConstructorInvoke(
+  R visitLogicalOr(
       Send node,
-      ConstructorElement thisConstructor,
-      NodeList arguments,
-      Selector selector,
+      Node left,
+      Node right,
       A arg) {
-    return bulkHandleInitializer(node, arg);
+    return bulkHandleNode(node, 'Lazy or `#` unhandled.', arg);
   }
 }
 
-/// Mixin that implements all function declaration visitor methods of
-/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+/// Mixin that implements all visitor methods for `super` calls in
+/// [SemanticSendVisitor] by delegating to a bulk handler.
 ///
-/// Use this mixin to provide a trivial implementation for these methods.
-abstract class FunctionBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+/// Use this mixin to provide a trivial implementation for `super` calls
+/// visitor methods.
+abstract class SuperBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  R bulkHandleFunctionDeclaration(FunctionExpression node, A arg) {
-    return bulkHandleNode(
-        node, "Function declaration `#` unhandled.", arg);
+  R bulkHandleSuper(Send node, A arg) {
+    return bulkHandleNode(node, "Super call `#` unhandled.", arg);
   }
 
   @override
-  R visitAbstractGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
+  R visitSuperBinary(
+      Send node,
+      FunctionElement function,
+      BinaryOperator operator,
+      Node argument,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitAbstractMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
+  R visitSuperCompoundIndexSet(
+      SendSet node,
+      FunctionElement getter,
+      FunctionElement setter,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitAbstractSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
+  R visitSuperEquals(
+      Send node,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitClosureDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement closure,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitInstanceGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
+  R visitSuperFieldFieldPostfix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitInstanceMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldFieldPrefix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitInstanceSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldGet(
+      Send node,
+      FieldElement field,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitLocalFunctionDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement function,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitStaticFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitStaticGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
+  R visitSuperFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitStaticSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitTopLevelFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldSetterCompound(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitTopLevelGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
+  R visitSuperFieldSetterPostfix(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitTopLevelSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitSuperFieldSetterPrefix(
+      Send node,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleFunctionDeclaration(node, arg);
-  }
-}
-
-/// Mixin that implements all variable/field declaration visitor methods of
-/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
-///
-/// Use this mixin to provide a trivial implementation for these methods.
-abstract class VariableBulkMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
-
-  R bulkHandleVariableDeclaration(VariableDefinitions node, A arg) {
-    return bulkHandleNode(
-        node, "Variable declaration `#` unhandled.", arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitInstanceFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
+  R visitSuperGetterFieldCompound(
+      Send node,
+      FunctionElement getter,
       FieldElement field,
-      Node initializer,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitLocalConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
-      ConstantExpression constant,
+  R visitSuperGetterFieldPostfix(
+      Send node,
+      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitLocalVariableDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
-      Node initializer,
-      A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
-  }
-
-  @override
-  R visitStaticConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
+  R visitSuperGetterFieldPrefix(
+      Send node,
+      FunctionElement getter,
       FieldElement field,
-      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitStaticFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
+  R visitSuperGetterGet(
+      Send node,
+      FunctionElement getter,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitTopLevelConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      ConstantExpression constant,
+  R visitSuperGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitTopLevelFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
+  R visitSuperGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return bulkHandleVariableDeclaration(node, arg);
-  }
-}
-
-/// Visitor that implements [SemanticDeclarationVisitor] by the use of `BulkX`
-/// mixins.
-///
-/// This class is useful in itself, but shows how to use the `BulkX` mixins and
-/// tests that the union of the `BulkX` mixins implement all `visit` and `error`
-/// methods of [SemanticDeclarationVisitor].
-class BulkDeclarationVisitor<R, A> extends SemanticDeclarationVisitor<R, A>
-    with ConstructorBulkMixin<R, A>,
-         FunctionBulkMixin<R, A>,
-         VariableBulkMixin<R, A>,
-         ParameterBulkMixin<R, A>,
-         InitializerBulkMixin<R, A> {
-  @override
-  R apply(Node node, A arg) {
-    throw new UnimplementedError("BulkDeclVisitor.apply unimplemented");
-  }
-
-  @override
-  R bulkHandleNode(Node node, String message, A arg) {
-    throw new UnimplementedError(
-        "BulkDeclVisitor.bulkHandleNode unimplemented");
-  }
-
-  @override
-  applyInitializers(NodeList initializers, A arg) {
-    throw new UnimplementedError(
-        "BulkDeclVisitor.applyInitializers unimplemented");
-  }
-
-  @override
-  applyParameters(NodeList parameters, A arg) {
-    throw new UnimplementedError(
-        "BulkDeclVisitor.applyParameters unimplemented");
-  }
-}
-
-
-/// [SemanticSendVisitor] that visits subnodes.
-class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
-  @override
-  R apply(Node node, A arg) {
-    throw new UnimplementedError("TraversalMixin.apply unimplemented");
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorInvalidAssert(
+  R visitSuperGetterSetterPostfix(
       Send node,
-      NodeList arguments,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorClassTypeLiteralSet(
-      SendSet node,
-      ConstantExpression constant,
-      Node rhs,
+  R visitSuperGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorDynamicTypeLiteralSet(
+  R visitSuperIndexSet(
       SendSet node,
-      ConstantExpression constant,
+      FunctionElement function,
+      Node index,
       Node rhs,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalLocalVariableCompound(
+  R visitSuperMethodGet(
       Send node,
-      LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
+      MethodElement method,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
+  R visitSuperMethodInvoke(
+      Send node,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalParameterCompound(
+  R visitSuperMethodIncompatibleInvoke(
       Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalParameterSet(
-      SendSet node,
-      ParameterElement parameter,
+  R visitSuperMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalStaticFieldCompound(
+  R visitSuperMethodSetterPostfix(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalStaticFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitSuperMethodSetterPrefix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalSuperFieldCompound(
+  R visitSuperNotEquals(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalSuperFieldSet(
+  R visitSuperSetterSet(
       SendSet node,
-      FieldElement field,
+      FunctionElement setter,
       Node rhs,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalTopLevelFieldCompound(
+  R visitSuperUnary(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      UnaryOperator operator,
+      FunctionElement function,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorFinalTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitUnresolvedSuperBinary(
+      Send node,
+      Element element,
+      BinaryOperator operator,
+      Node argument,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorLocalFunctionCompound(
+  R visitUnresolvedSuperGet(
       Send node,
-      LocalFunctionElement function,
-      AssignmentOperator operator,
-      Node rhs,
+      Element element,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorLocalFunctionPostfix(
+  R visitUnresolvedSuperInvoke(
       Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
+      Element function,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorLocalFunctionPrefix(
+  R visitUnresolvedSuperIndex(
       Send node,
-      LocalFunctionElement function,
-      IncDecOperator operator,
+      Element function,
+      Node index,
       A arg) {
-    return null;
+    return bulkHandleSuper(node, arg);
   }
 
   @override
-  R errorLocalFunctionSet(
-      SendSet node,
-      LocalFunctionElement function,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
-  }
-
-  @override
-  R errorStaticFunctionSet(
+  R visitUnresolvedSuperUnary(
       Send node,
-      MethodElement function,
-      Node rhs,
+      UnaryOperator operator,
+      Element element,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleSuper(node, arg);
   }
+}
 
-  @override
-  R errorStaticGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
-  }
+abstract class NewBulkMixin<R, A>
+    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
-  @override
-  R errorStaticSetterGet(
-      Send node,
-      FunctionElement setter,
-      A arg) {
-    return null;
+  R bulkHandleNew(NewExpression node, A arg) {
+    return bulkHandleNode(
+        node, "Constructor invocation `#` unhandled.", arg);
   }
 
   @override
-  R errorStaticSetterInvoke(
-      Send node,
-      FunctionElement setter,
+  R visitAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorSuperGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorSuperMethodSet(
-      Send node,
-      MethodElement method,
-      Node rhs,
+  R visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorSuperSetterGet(
-      Send node,
-      FunctionElement setter,
+  R visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorSuperSetterInvoke(
-      Send node,
-      FunctionElement setter,
+  R visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorTopLevelFunctionSet(
-      Send node,
-      MethodElement function,
-      Node rhs,
+  R visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorTopLevelGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
+  R visitUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element element,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorTopLevelSetterGet(
-      Send node,
-      FunctionElement setter,
+  R visitUnresolvedConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return null;
+    return bulkHandleNew(node, arg);
   }
 
   @override
-  R errorTopLevelSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    apply(arguments, arg);
-    return null;
+  R visitUnresolvedRedirectingFactoryConstructorInvoke(
+       NewExpression node,
+       ConstructorElement constructor,
+       InterfaceType type,
+       NodeList arguments,
+       CallStructure callStructure,
+       A arg) {
+    return bulkHandleNew(node, arg);
   }
+}
 
+/// Visitor that implements [SemanticSendVisitor] by the use of `BulkX` mixins.
+///
+/// This class is useful in itself, but shows how to use the `BulkX` mixins and
+/// tests that the union of the `BulkX` mixins implement all `visit` and `error`
+/// methods of [SemanticSendVisitor].
+class BulkSendVisitor<R, A> extends SemanticSendVisitor<R, A>
+    with GetBulkMixin<R, A>,
+         SetBulkMixin<R, A>,
+         ErrorBulkMixin<R, A>,
+         InvokeBulkMixin<R, A>,
+         IndexSetBulkMixin<R, A>,
+         CompoundBulkMixin<R, A>,
+         UnaryBulkMixin<R, A>,
+         BaseBulkMixin<R, A>,
+         BinaryBulkMixin<R, A>,
+         PrefixBulkMixin<R, A>,
+         PostfixBulkMixin<R, A>,
+         NewBulkMixin<R, A> {
   @override
-  R errorTypeVariableTypeLiteralSet(
-      SendSet node,
-      TypeVariableElement element,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
+  R apply(Node node, A arg) {
+    throw new UnimplementedError("BulkSendVisitor.apply unimplemented");
   }
 
   @override
-  R errorTypedefTypeLiteralSet(
-      SendSet node,
-      ConstantExpression constant,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
+  R bulkHandleNode(Node node, String message, A arg) {
+    throw new UnimplementedError(
+        "BulkSendVisitor.bulkHandleNode unimplemented");
+  }
+}
+
+/// Mixin that implements all `visitXParameterDecl` and
+/// `visitXInitializingFormalDecl` methods of [SemanticDeclarationVisitor]
+/// by delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for these methods.
+abstract class ParameterBulkMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleParameterDeclaration(VariableDefinitions node, A arg) {
+    return bulkHandleNode(
+        node, "Parameter declaration `#` unhandled.", arg);
   }
 
   @override
-  R visitUnresolvedSuperIndex(
-      Send node,
-      Element function,
-      Node index,
+  R visitInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement parameter,
+      int index,
       A arg) {
-    apply(index, arg);
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGet(
-      Send node,
-      Element element,
+  R visitNamedInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement parameter,
+      ConstantExpression defaultValue,
       A arg) {
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperInvoke(
-      Send node,
-      Element function,
-      NodeList arguments,
-      Selector selector,
+  R visitNamedParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      ConstantExpression defaultValue,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
 
   @override
-  R visitAs(
-      Send node,
-      Node expression,
-      DartType type,
+  R visitOptionalInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement parameter,
+      ConstantExpression defaultValue,
+      int index,
       A arg) {
-    apply(expression, arg);
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
 
   @override
-  R visitAssert(
-      Send node,
-      Node expression,
+  R visitOptionalParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      ConstantExpression defaultValue,
+      int index,
       A arg) {
-    apply(expression, arg);
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
 
   @override
-  R visitBinary(
-      Send node,
-      Node left,
-      BinaryOperator operator,
-      Node right,
+  R visitParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      int index,
       A arg) {
-    apply(left, arg);
-    apply(right, arg);
-    return null;
+    return bulkHandleParameterDeclaration(node, arg);
   }
+}
 
-  @override
-  R errorClassTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
+/// Mixin that implements all `visitXConstructorDecl` methods of
+/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for these methods.
+abstract class ConstructorBulkMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleConstructorDeclaration(FunctionExpression node, A arg) {
+    return bulkHandleNode(
+        node, "Constructor declaration `#` unhandled.", arg);
   }
 
   @override
-  R visitClassTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
+  R visitFactoryConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      Node body,
       A arg) {
-    return null;
+    return bulkHandleConstructorDeclaration(node, arg);
   }
 
   @override
-  R visitClassTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitGenerativeConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      NodeList initializers,
+      Node body,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleConstructorDeclaration(node, arg);
   }
 
   @override
-  R errorClassTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
+  R visitRedirectingFactoryConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      InterfaceType redirectionType,
+      ConstructorElement redirectionTarget,
       A arg) {
-    return null;
+    return bulkHandleConstructorDeclaration(node, arg);
   }
 
   @override
-  R errorClassTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
+  R visitRedirectingGenerativeConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      NodeList initializers,
       A arg) {
-    return null;
+    return bulkHandleConstructorDeclaration(node, arg);
+  }
+}
+
+/// Mixin that implements all constructor initializer visitor methods of
+/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for these methods.
+abstract class InitializerBulkMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleInitializer(Send node, A arg) {
+    return bulkHandleNode(
+        node, "Initializer `#` unhandled.", arg);
   }
 
   @override
-  R visitCompoundIndexSet(
+  R errorUnresolvedFieldInitializer(
       SendSet node,
-      Node receiver,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
+      Element element,
+      Node initializer,
       A arg) {
-    apply(receiver, arg);
-    apply(index, arg);
-    apply(rhs, arg);
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitConstantGet(
+  R errorUnresolvedSuperConstructorInvoke(
       Send node,
-      ConstantExpression constant,
+      Element element,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitConstantInvoke(
+  R errorUnresolvedThisConstructorInvoke(
       Send node,
-      ConstantExpression constant,
+      Element element,
       NodeList arguments,
-      CallStructure callStructure,
+      Selector selector,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitDynamicPropertyCompound(
-      Send node,
-      Node receiver,
-      AssignmentOperator operator,
-      Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
+  R visitFieldInitializer(
+      SendSet node,
+      FieldElement field,
+      Node initializer,
       A arg) {
-    apply(receiver, arg);
-    apply(rhs, arg);
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitDynamicPropertyGet(
+  R visitSuperConstructorInvoke(
       Send node,
-      Node receiver,
+      ConstructorElement superConstructor,
+      InterfaceType type,
+      NodeList arguments,
       Selector selector,
       A arg) {
-    apply(receiver, arg);
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
 
   @override
-  R visitDynamicPropertyInvoke(
+  R visitThisConstructorInvoke(
       Send node,
-      Node receiver,
+      ConstructorElement thisConstructor,
       NodeList arguments,
       Selector selector,
       A arg) {
-    apply(receiver, arg);
-    apply(arguments, arg);
-    return null;
+    return bulkHandleInitializer(node, arg);
   }
+}
 
-  @override
-  R visitDynamicPropertyPostfix(
-      Send node,
-      Node receiver,
-      IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
-      A arg) {
-    apply(receiver, arg);
-    return null;
+/// Mixin that implements all function declaration visitor methods of
+/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for these methods.
+abstract class FunctionBulkMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleFunctionDeclaration(FunctionExpression node, A arg) {
+    return bulkHandleNode(
+        node, "Function declaration `#` unhandled.", arg);
   }
 
   @override
-  R visitDynamicPropertyPrefix(
-      Send node,
-      Node receiver,
-      IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
+  R visitAbstractGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
       A arg) {
-    apply(receiver, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitDynamicPropertySet(
-      SendSet node,
-      Node receiver,
-      Selector selector,
-      Node rhs,
+  R visitAbstractMethodDeclaration(
+      FunctionExpression node,
+      MethodElement method,
+      NodeList parameters,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R errorDynamicTypeLiteralCompound(
-      Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
+  R visitAbstractSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitDynamicTypeLiteralGet(
-      Send node,
-      ConstantExpression constant,
+  R visitClosureDeclaration(
+      FunctionExpression node,
+      LocalFunctionElement closure,
+      NodeList parameters,
+      Node body,
       A arg) {
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitDynamicTypeLiteralInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitInstanceGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R errorDynamicTypeLiteralPostfix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
+  R visitInstanceMethodDeclaration(
+      FunctionExpression node,
+      MethodElement method,
+      NodeList parameters,
+      Node body,
       A arg) {
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R errorDynamicTypeLiteralPrefix(
-      Send node,
-      ConstantExpression constant,
-      IncDecOperator operator,
+  R visitInstanceSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
       A arg) {
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitEquals(
-      Send node,
-      Node left,
-      Node right,
-      A arg) {
-    apply(left, arg);
-    apply(right, arg);
-    return null;
+  R visitLocalFunctionDeclaration(
+      FunctionExpression node,
+      LocalFunctionElement function,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitExpressionInvoke(
-      Send node,
-      Node expression,
-      NodeList arguments,
-      Selector selector,
+  R visitStaticFunctionDeclaration(
+      FunctionExpression node,
+      MethodElement function,
+      NodeList parameters,
+      Node body,
       A arg) {
-    apply(expression, arg);
-    apply(arguments, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitIndex(
-      Send node,
-      Node receiver,
-      Node index,
+  R visitStaticGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
       A arg) {
-    apply(receiver, arg);
-    apply(index, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitIndexSet(
-      SendSet node,
-      Node receiver,
-      Node index,
-      Node rhs,
+  R visitStaticSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
       A arg) {
-    apply(receiver, arg);
-    apply(index, arg);
-    apply(rhs, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitIs(
-      Send node,
-      Node expression,
-      DartType type,
+  R visitTopLevelFunctionDeclaration(
+      FunctionExpression node,
+      MethodElement function,
+      NodeList parameters,
+      Node body,
       A arg) {
-    apply(expression, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitIsNot(
-      Send node,
-      Node expression,
-      DartType type,
+  R visitTopLevelGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
       A arg) {
-    apply(expression, arg);
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
 
   @override
-  R visitLocalFunctionGet(
-      Send node,
-      LocalFunctionElement function,
+  R visitTopLevelSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
       A arg) {
-    return null;
+    return bulkHandleFunctionDeclaration(node, arg);
   }
+}
 
-  @override
-  R visitLocalFunctionInvoke(
-      Send node,
-      LocalFunctionElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg) {
-    apply(arguments, arg);
-    return null;
+/// Mixin that implements all variable/field declaration visitor methods of
+/// [SemanticDeclarationVisitor] by delegating to a bulk handler.
+///
+/// Use this mixin to provide a trivial implementation for these methods.
+abstract class VariableBulkMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A>, BulkHandle<R, A> {
+
+  R bulkHandleVariableDeclaration(VariableDefinitions node, A arg) {
+    return bulkHandleNode(
+        node, "Variable declaration `#` unhandled.", arg);
   }
 
   @override
-  R visitLocalVariableCompound(
-      Send node,
-      LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
+  R visitInstanceFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLocalVariableGet(
-      Send node,
+  R visitLocalConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
       LocalVariableElement variable,
+      ConstantExpression constant,
       A arg) {
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLocalVariableInvoke(
-      Send node,
+  R visitLocalVariableDeclaration(
+      VariableDefinitions node,
+      Node definition,
       LocalVariableElement variable,
-      NodeList arguments,
-      CallStructure callStructure,
+      Node initializer,
       A arg) {
-    apply(arguments, arg);
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLocalVariablePostfix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
+  R visitStaticConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      ConstantExpression constant,
       A arg) {
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLocalVariablePrefix(
-      Send node,
-      LocalVariableElement variable,
-      IncDecOperator operator,
+  R visitStaticFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
       A arg) {
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
+  R visitTopLevelConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      ConstantExpression constant,
       A arg) {
-    apply(rhs, arg);
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
 
   @override
-  R visitLogicalAnd(
-      Send node,
-      Node left,
-      Node right,
+  R visitTopLevelFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
       A arg) {
-    apply(left, arg);
-    apply(right, arg);
-    return null;
+    return bulkHandleVariableDeclaration(node, arg);
   }
+}
 
+/// Visitor that implements [SemanticDeclarationVisitor] by the use of `BulkX`
+/// mixins.
+///
+/// This class is useful in itself, but shows how to use the `BulkX` mixins and
+/// tests that the union of the `BulkX` mixins implement all `visit` and `error`
+/// methods of [SemanticDeclarationVisitor].
+class BulkDeclarationVisitor<R, A> extends SemanticDeclarationVisitor<R, A>
+    with ConstructorBulkMixin<R, A>,
+         FunctionBulkMixin<R, A>,
+         VariableBulkMixin<R, A>,
+         ParameterBulkMixin<R, A>,
+         InitializerBulkMixin<R, A> {
   @override
-  R visitLogicalOr(
-      Send node,
-      Node left,
-      Node right,
-      A arg) {
-    apply(left, arg);
-    apply(right, arg);
-    return null;
+  R apply(Node node, A arg) {
+    throw new UnimplementedError("BulkDeclVisitor.apply unimplemented");
   }
 
   @override
-  R visitNot(
-      Send node,
-      Node expression,
-      A arg) {
-    apply(expression, arg);
-    return null;
+  R bulkHandleNode(Node node, String message, A arg) {
+    throw new UnimplementedError(
+        "BulkDeclVisitor.bulkHandleNode unimplemented");
   }
 
   @override
-  R visitNotEquals(
-      Send node,
-      Node left,
-      Node right,
-      A arg) {
-    apply(left, arg);
-    apply(right, arg);
-    return null;
+  applyInitializers(NodeList initializers, A arg) {
+    throw new UnimplementedError(
+        "BulkDeclVisitor.applyInitializers unimplemented");
   }
 
   @override
-  R visitParameterCompound(
-      Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg) {
-    apply(rhs, arg);
-    return null;
+  applyParameters(NodeList parameters, A arg) {
+    throw new UnimplementedError(
+        "BulkDeclVisitor.applyParameters unimplemented");
   }
+}
 
+
+/// [SemanticSendVisitor] that visits subnodes.
+class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   @override
-  R visitParameterGet(
-      Send node,
-      ParameterElement parameter,
-      A arg) {
-    return null;
+  R apply(Node node, A arg) {
+    throw new UnimplementedError("TraversalMixin.apply unimplemented");
   }
 
   @override
-  R visitParameterInvoke(
+  R errorInvalidAssert(
       Send node,
-      ParameterElement parameter,
       NodeList arguments,
-      CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitParameterPostfix(
-      Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
+  R errorClassTypeLiteralSet(
+      SendSet node,
+      ConstantExpression constant,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitParameterPrefix(
+  R errorDynamicTypeLiteralSet(
+      SendSet node,
+      ConstantExpression constant,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;

[karlklose, 2015/05/13 07:25:59]

Remove 'return null'?

[Johnni Winther, 2015/05/13 08:48:00]

It would add a hint of missing return :(

+  }
+
+  @override
+  R visitFinalLocalVariableCompound(
       Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
+      LocalVariableElement variable,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitParameterSet(
+  R errorFinalLocalVariableSet(
       SendSet node,
-      ParameterElement parameter,
+      LocalVariableElement variable,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -3758,9 +3402,9 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitStaticFieldCompound(
+  R visitFinalParameterCompound(
       Send node,
-      FieldElement field,
+      ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
@@ -3769,44 +3413,59 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitStaticFieldGet(
+  R errorFinalParameterSet(
+      SendSet node,
+      ParameterElement parameter,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFinalFieldCompound(
       Send node,
       FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFieldInvoke(
-      Send node,
+  R errorFinalStaticFieldSet(
+      SendSet node,
       FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      Node rhs,
       A arg) {
-    apply(arguments, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFieldPostfix(
-      Send node,
+  R errorFinalSuperFieldSet(
+      SendSet node,
       FieldElement field,
-      IncDecOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFieldPrefix(
+  R visitTopLevelFinalFieldCompound(
       Send node,
       FieldElement field,
-      IncDecOperator operator,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFieldSet(
+  R errorFinalTopLevelFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
@@ -3816,60 +3475,58 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitStaticFunctionGet(
+  R visitLocalFunctionCompound(
       Send node,
-      MethodElement function,
+      LocalFunctionElement function,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFunctionInvoke(
+  R visitLocalFunctionPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      LocalFunctionElement function,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitStaticFunctionIncompatibleInvoke(
+  R visitLocalFunctionPrefix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      LocalFunctionElement function,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterGet(
-      Send node,
-      FunctionElement getter,
+  R errorLocalFunctionSet(
+      SendSet node,
+      LocalFunctionElement function,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterInvoke(
+  R errorStaticFunctionSet(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement function,
+      Node rhs,
       A arg) {
-    apply(arguments, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterSetterCompound(
-      Send node,
+  R errorStaticGetterSet(
+      SendSet node,
       FunctionElement getter,
-      FunctionElement setter,
-      AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -3877,31 +3534,28 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitStaticGetterSetterPostfix(
+  R errorStaticSetterGet(
       Send node,
-      FunctionElement getter,
       FunctionElement setter,
-      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitStaticGetterSetterPrefix(
+  R errorStaticSetterInvoke(
       Send node,
-      FunctionElement getter,
       FunctionElement setter,
-      IncDecOperator operator,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitStaticMethodSetterCompound(
-      Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
+  R errorSuperGetterSet(
+      SendSet node,
+      FunctionElement getter,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -3909,53 +3563,48 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitStaticMethodSetterPostfix(
+  R errorSuperMethodSet(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
+      MethodElement method,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticMethodSetterPrefix(
+  R errorSuperSetterGet(
       Send node,
-      FunctionElement getter,
       FunctionElement setter,
-      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitStaticSetterSet(
-      SendSet node,
+  R errorSuperSetterInvoke(
+      Send node,
       FunctionElement setter,
-      Node rhs,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(rhs, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperBinary(
+  R errorTopLevelFunctionSet(
       Send node,
-      FunctionElement function,
-      BinaryOperator operator,
-      Node argument,
+      MethodElement function,
+      Node rhs,
       A arg) {
-    apply(argument, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperCompoundIndexSet(
+  R errorTopLevelGetterSet(
       SendSet node,
       FunctionElement getter,
-      FunctionElement setter,
-      Node index,
-      AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -3963,20 +3612,28 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitSuperEquals(
+  R errorTopLevelSetterGet(
       Send node,
-      FunctionElement function,
-      Node argument,
+      FunctionElement setter,
       A arg) {
-    apply(argument, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldCompound(
+  R errorTopLevelSetterInvoke(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
+      FunctionElement setter,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorTypeVariableTypeLiteralSet(
+      SendSet node,
+      TypeVariableElement element,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -3984,77 +3641,79 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitSuperFieldFieldPostfix(
-      Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
+  R errorTypedefTypeLiteralSet(
+      SendSet node,
+      ConstantExpression constant,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldFieldPrefix(
+  R visitUnresolvedSuperIndex(
       Send node,
-      FieldElement readField,
-      FieldElement writtenField,
-      IncDecOperator operator,
+      Element function,
+      Node index,
       A arg) {
+    apply(index, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldGet(
+  R visitUnresolvedSuperGet(
       Send node,
-      FieldElement field,
+      Element element,
       A arg) {
     return null;
   }
 
   @override
-  R visitSuperFieldInvoke(
+  R visitUnresolvedSuperInvoke(
       Send node,
-      FieldElement field,
+      Element function,
       NodeList arguments,
-      CallStructure callStructure,
+      Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldPostfix(
+  R visitAs(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      Node expression,
+      DartType type,
       A arg) {
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldPrefix(
+  R visitAssert(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      Node expression,
       A arg) {
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitBinary(
+      Send node,
+      Node left,
+      BinaryOperator operator,
+      Node right,
       A arg) {
-    apply(rhs, arg);
+    apply(left, arg);
+    apply(right, arg);
     return null;
   }
 
   @override
-  R visitSuperFieldSetterCompound(
+  R visitClassTypeLiteralCompound(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
@@ -4063,69 +3722,68 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitSuperFieldSetterPostfix(
+  R visitClassTypeLiteralGet(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
+      ConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
-  R visitSuperFieldSetterPrefix(
+  R visitClassTypeLiteralInvoke(
       Send node,
-      FieldElement field,
-      FunctionElement setter,
-      IncDecOperator operator,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterFieldCompound(
+  R visitClassTypeLiteralPostfix(
       Send node,
-      FunctionElement getter,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterFieldPostfix(
+  R visitClassTypeLiteralPrefix(
       Send node,
-      FunctionElement getter,
-      FieldElement field,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterFieldPrefix(
-      Send node,
-      FunctionElement getter,
-      FieldElement field,
-      IncDecOperator operator,
+  R visitCompoundIndexSet(
+      SendSet node,
+      Node receiver,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterGet(
+  R visitConstantGet(
       Send node,
-      FunctionElement getter,
+      ConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterInvoke(
+  R visitConstantInvoke(
       Send node,
-      FunctionElement getter,
+      ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
@@ -4134,82 +3792,99 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitSuperGetterSetterCompound(
+  R visitDynamicPropertyCompound(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Node receiver,
       AssignmentOperator operator,
       Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
+    apply(receiver, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterSetterPostfix(
+  R visitDynamicPropertyGet(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
+      Node receiver,
+      Selector selector,
       A arg) {
+    apply(receiver, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterSetterPrefix(
+  R visitDynamicPropertyInvoke(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      Node receiver,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(receiver, arg);
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitDynamicPropertyPostfix(
+      Send node,
+      Node receiver,
       IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
+    apply(receiver, arg);
     return null;
   }
 
   @override
-  R visitSuperIndex(
+  R visitDynamicPropertyPrefix(
       Send node,
-      FunctionElement function,
-      Node index,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    apply(index, arg);
+    apply(receiver, arg);
     return null;
   }
 
   @override
-  R visitSuperIndexSet(
+  R visitDynamicPropertySet(
       SendSet node,
-      FunctionElement function,
-      Node index,
+      Node receiver,
+      Selector selector,
       Node rhs,
       A arg) {
-    apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperMethodGet(
+  R visitDynamicTypeLiteralCompound(
       Send node,
-      MethodElement method,
+      ConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperMethodInvoke(
+  R visitDynamicTypeLiteralGet(
       Send node,
-      MethodElement method,
-      NodeList arguments,
-      CallStructure callStructure,
+      ConstantExpression constant,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperMethodIncompatibleInvoke(
+  R visitDynamicTypeLiteralInvoke(
       Send node,
-      MethodElement method,
+      ConstantExpression constant,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
@@ -4218,74 +3893,102 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitSuperMethodSetterCompound(
+  R visitDynamicTypeLiteralPostfix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperMethodSetterPostfix(
+  R visitDynamicTypeLiteralPrefix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitSuperMethodSetterPrefix(
+  R visitEquals(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
-      IncDecOperator operator,
+      Node left,
+      Node right,
       A arg) {
+    apply(left, arg);
+    apply(right, arg);
     return null;
   }
 
   @override
-  R visitSuperNotEquals(
+  R visitExpressionInvoke(
       Send node,
-      FunctionElement function,
-      Node argument,
+      Node expression,
+      NodeList arguments,
+      Selector selector,
       A arg) {
-    apply(argument, arg);
+    apply(expression, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperSetterSet(
+  R visitIndex(
+      Send node,
+      Node receiver,
+      Node index,
+      A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitIndexSet(
       SendSet node,
-      FunctionElement setter,
+      Node receiver,
+      Node index,
       Node rhs,
       A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperUnary(
+  R visitIs(
       Send node,
-      UnaryOperator operator,
-      FunctionElement function,
+      Node expression,
+      DartType type,
       A arg) {
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitThisGet(Identifier node, A arg) {
+  R visitIsNot(
+      Send node,
+      Node expression,
+      DartType type,
+      A arg) {
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitThisInvoke(
+  R visitLocalFunctionGet(
+      Send node,
+      LocalFunctionElement function,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitLocalFunctionInvoke(
       Send node,
+      LocalFunctionElement function,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
@@ -4294,59 +3997,57 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitThisPropertyCompound(
+  R visitLocalVariableCompound(
       Send node,
+      LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitThisPropertyGet(
+  R visitLocalVariableGet(
       Send node,
-      Selector selector,
+      LocalVariableElement variable,
       A arg) {
     return null;
   }
 
   @override
-  R visitThisPropertyInvoke(
+  R visitLocalVariableInvoke(
       Send node,
+      LocalVariableElement variable,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitThisPropertyPostfix(
+  R visitLocalVariablePostfix(
       Send node,
+      LocalVariableElement variable,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return null;
   }
 
   @override
-  R visitThisPropertyPrefix(
+  R visitLocalVariablePrefix(
       Send node,
+      LocalVariableElement variable,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return null;
   }
 
   @override
-  R visitThisPropertySet(
+  R visitLocalVariableSet(
       SendSet node,
-      Selector selector,
+      LocalVariableElement variable,
       Node rhs,
       A arg) {
     apply(rhs, arg);
@@ -4354,65 +4055,165 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelFieldCompound(
+  R visitLogicalAnd(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      Node left,
+      Node right,
       A arg) {
-    apply(rhs, arg);
+    apply(left, arg);
+    apply(right, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFieldGet(
+  R visitLogicalOr(
       Send node,
-      FieldElement field,
+      Node left,
+      Node right,
       A arg) {
+    apply(left, arg);
+    apply(right, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFieldInvoke(
+  R visitNot(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      Node expression,
       A arg) {
-    apply(arguments, arg);
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFieldPostfix(
+  R visitNotEquals(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      Node left,
+      Node right,
       A arg) {
+    apply(left, arg);
+    apply(right, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFieldPrefix(
+  R visitParameterCompound(
       Send node,
-      FieldElement field,
-      IncDecOperator operator,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitParameterGet(
+      Send node,
+      ParameterElement parameter,
       A arg) {
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFunctionGet(
+  R visitParameterInvoke(
+      Send node,
+      ParameterElement parameter,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitParameterPostfix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitParameterPrefix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitParameterSet(
+      SendSet node,
+      ParameterElement parameter,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFieldGet(
+      Send node,
+      FieldElement field,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFunctionGet(
       Send node,
       MethodElement function,
       A arg) {
@@ -4420,7 +4221,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelFunctionInvoke(
+  R visitStaticFunctionInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
@@ -4431,7 +4232,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelFunctionIncompatibleInvoke(
+  R visitStaticFunctionIncompatibleInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
@@ -4442,7 +4243,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelGetterGet(
+  R visitStaticGetterGet(
       Send node,
       FunctionElement getter,
       A arg) {
@@ -4450,7 +4251,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelGetterInvoke(
+  R visitStaticGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
@@ -4461,7 +4262,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelGetterSetterCompound(
+  R visitStaticGetterSetterCompound(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
@@ -4473,7 +4274,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelGetterSetterPostfix(
+  R visitStaticGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
@@ -4483,7 +4284,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelGetterSetterPrefix(
+  R visitStaticGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
@@ -4493,7 +4294,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelMethodSetterCompound(
+  R visitStaticMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
@@ -4505,9 +4306,9 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelMethodSetterPostfix(
+  R visitStaticMethodSetterPostfix(
       Send node,
-      FunctionElement method,
+      FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
@@ -4515,9 +4316,9 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelMethodSetterPrefix(
+  R visitStaticMethodSetterPrefix(
       Send node,
-      FunctionElement method,
+      FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
@@ -4525,7 +4326,7 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitTopLevelSetterSet(
+  R visitStaticSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
@@ -4535,76 +4336,82 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R errorTypeVariableTypeLiteralCompound(
+  R visitSuperBinary(
       Send node,
-      TypeVariableElement element,
-      AssignmentOperator operator,
-      Node rhs,
+      FunctionElement function,
+      BinaryOperator operator,
+      Node argument,
       A arg) {
-    apply(rhs, arg);
+    apply(argument, arg);
     return null;
   }
 
   @override
-  R visitTypeVariableTypeLiteralGet(
-      Send node,
-      TypeVariableElement element,
+  R visitSuperCompoundIndexSet(
+      SendSet node,
+      FunctionElement getter,
+      FunctionElement setter,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTypeVariableTypeLiteralInvoke(
+  R visitSuperEquals(
       Send node,
-      TypeVariableElement element,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    apply(arguments, arg);
+    apply(argument, arg);
     return null;
   }
 
   @override
-  R errorTypeVariableTypeLiteralPostfix(
+  R visitSuperFieldCompound(
       Send node,
-      TypeVariableElement element,
-      IncDecOperator operator,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R errorTypeVariableTypeLiteralPrefix(
+  R visitSuperFieldFieldPostfix(
       Send node,
-      TypeVariableElement element,
+      FieldElement readField,
+      FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R errorTypedefTypeLiteralCompound(
+  R visitSuperFieldFieldPrefix(
       Send node,
-      ConstantExpression constant,
-      AssignmentOperator operator,
-      Node rhs,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTypedefTypeLiteralGet(
+  R visitSuperFieldGet(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
       A arg) {
     return null;
   }
 
   @override
-  R visitTypedefTypeLiteralInvoke(
+  R visitSuperFieldInvoke(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
@@ -4613,37 +4420,38 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R errorTypedefTypeLiteralPostfix(
+  R visitSuperFieldPostfix(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R errorTypedefTypeLiteralPrefix(
+  R visitSuperFieldPrefix(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitUnary(
-      Send node,
-      UnaryOperator operator,
-      Node expression,
+  R visitSuperFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
       A arg) {
-    apply(expression, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedCompound(
+  R visitSuperFieldSetterCompound(
       Send node,
-      Element element,
+      FieldElement field,
+      FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
@@ -4652,106 +4460,123 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitUnresolvedGet(
+  R visitSuperFieldSetterPostfix(
       Send node,
-      Element element,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedInvoke(
+  R visitSuperFieldSetterPrefix(
       Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
+      FieldElement field,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedPostfix(
+  R visitSuperGetterFieldCompound(
       Send node,
-      Element element,
-      IncDecOperator operator,
+      FunctionElement getter,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedPrefix(
+  R visitSuperGetterFieldPostfix(
       Send node,
-      Element element,
+      FunctionElement getter,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R errorUnresolvedSet(
+  R visitSuperGetterFieldPrefix(
       Send node,
-      Element element,
-      Node rhs,
+      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R errorUndefinedBinaryExpression(
+  R visitSuperGetterGet(
       Send node,
-      Node left,
-      Operator operator,
-      Node right,
+      FunctionElement getter,
       A arg) {
-    apply(left, arg);
-    apply(right, arg);
     return null;
   }
 
   @override
-  R errorUndefinedUnaryExpression(
+  R visitSuperGetterInvoke(
       Send node,
-      Operator operator,
-      Node expression,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(expression, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperIndexSet(
+  R visitSuperGetterSetterCompound(
       Send node,
-      Element element,
-      Node index,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterCompoundIndexSet(
-      SendSet node,
-      Element element,
+  R visitSuperGetterSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperIndex(
+      Send node,
+      FunctionElement function,
       Node index,
-      AssignmentOperator operator,
-      Node rhs,
       A arg) {
     apply(index, arg);
-    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterCompoundIndexSet(
+  R visitSuperIndexSet(
       SendSet node,
-      MethodElement getter,
-      Element element,
+      FunctionElement function,
       Node index,
-      AssignmentOperator operator,
       Node rhs,
       A arg) {
     apply(index, arg);
@@ -4760,143 +4585,134 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitUnresolvedSuperBinary(
+  R visitSuperMethodGet(
       Send node,
-      Element element,
-      BinaryOperator operator,
-      Node argument,
+      MethodElement method,
       A arg) {
-    apply(argument, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperUnary(
+  R visitSuperMethodInvoke(
       Send node,
-      UnaryOperator operator,
-      Element element,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPostfix(
+  R visitSuperMethodIncompatibleInvoke(
       Send node,
-      Element element,
-      Node index,
-      IncDecOperator operator,
+      MethodElement method,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(index, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPostfix(
+  R visitSuperMethodSetterCompound(
       Send node,
-      MethodElement getter,
-      Element element,
-      Node index,
-      IncDecOperator operator,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    apply(index, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPrefix(
+  R visitSuperMethodSetterPostfix(
       Send node,
-      Element element,
-      Node index,
+      FunctionElement method,
+      FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    apply(index, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPrefix(
+  R visitSuperMethodSetterPrefix(
       Send node,
-      MethodElement getter,
-      Element element,
-      Node index,
+      FunctionElement method,
+      FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    apply(index, arg);
     return null;
   }
 
   @override
-  R visitIndexPostfix(
+  R visitSuperNotEquals(
       Send node,
-      Node receiver,
-      Node index,
-      IncDecOperator operator,
+      FunctionElement function,
+      Node argument,
       A arg) {
-    apply(receiver, arg);
-    apply(index, arg);
+    apply(argument, arg);
     return null;
   }
 
   @override
-  R visitIndexPrefix(
-      Send node,
-      Node receiver,
-      Node index,
-      IncDecOperator operator,
+  R visitSuperSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
       A arg) {
-    apply(receiver, arg);
-    apply(index, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperIndexPostfix(
+  R visitSuperUnary(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
-      Node index,
-      IncDecOperator operator,
+      UnaryOperator operator,
+      FunctionElement function,
       A arg) {
-    apply(index, arg);
     return null;
   }
 
   @override
-  R visitSuperIndexPrefix(
+  R visitThisGet(Identifier node, A arg) {
+    return null;
+  }
+
+  @override
+  R visitThisInvoke(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
-      Node index,
-      IncDecOperator operator,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    apply(index, arg);
+    apply(arguments, arg);
     return null;
   }
 
-  R visitConstConstructorInvoke(
-      NewExpression node,
-      ConstructedConstantExpression constant,
+  @override
+  R visitThisPropertyCompound(
+      Send node,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedClassConstructorInvoke(
-      NewExpression node,
-      Element constructor,
-      DartType type,
-      NodeList arguments,
+  R visitThisPropertyGet(
+      Send node,
       Selector selector,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedConstructorInvoke(
-      NewExpression node,
-      Element constructor,
-      DartType type,
+  R visitThisPropertyInvoke(
+      Send node,
       NodeList arguments,
       Selector selector,
       A arg) {
@@ -4905,72 +4721,58 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R visitFactoryConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitThisPropertyPostfix(
+      Send node,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitGenerativeConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitThisPropertyPrefix(
+      Send node,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitRedirectingFactoryConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      ConstructorElement effectiveTarget,
-      InterfaceType effectiveTargetType,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitThisPropertySet(
+      SendSet node,
+      Selector selector,
+      Node rhs,
       A arg) {
-    apply(arguments, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitRedirectingGenerativeConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitTopLevelFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    apply(arguments, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitAbstractClassConstructorInvoke(
-      NewExpression node,
-      ConstructorElement element,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitTopLevelFieldGet(
+      Send node,
+      FieldElement field,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedRedirectingFactoryConstructorInvoke(
-      NewExpression node,
-      ConstructorElement constructor,
-      InterfaceType type,
+  R visitTopLevelFieldInvoke(
+      Send node,
+      FieldElement field,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
@@ -4979,634 +4781,3049 @@ class TraversalSendMixin<R, A> implements SemanticSendVisitor<R, A> {
   }
 
   @override
-  R errorNonConstantConstructorInvoke(
-      NewExpression node,
-      Element element,
-      InterfaceType type,
-      NodeList arguments,
-      CallStructure callStructure,
+  R visitTopLevelFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
-}
 
-/// [SemanticDeclarationVisitor] that visits subnodes.
-class TraversalDeclarationMixin<R, A>
-    implements SemanticDeclarationVisitor<R, A> {
   @override
-  R apply(Node node, A arg) {
-    throw new UnimplementedError("TraversalMixin.apply unimplemented");
+  R visitTopLevelFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
   }
 
   @override
-  applyInitializers(NodeList initializers, A arg) {
-    throw new UnimplementedError(
-        "TraversalMixin.applyInitializers unimplemented");
-  }
-
-  @override
-  applyParameters(NodeList parameters, A arg) {
-    throw new UnimplementedError(
-        "TraversalMixin.applyParameters unimplemented");
+  R visitTopLevelFieldSet(
+      SendSet node,
+      FieldElement field,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
   }
 
   @override
-  R visitAbstractMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
+  R visitTopLevelFunctionGet(
+      Send node,
+      MethodElement function,
       A arg) {
-    applyParameters(parameters, arg);
     return null;
   }
 
   @override
-  R visitClosureDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement function,
-      NodeList parameters,
-      Node body,
+  R visitTopLevelFunctionInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitFactoryConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      Node body,
+  R visitTopLevelFunctionIncompatibleInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitFieldInitializer(
-      SendSet node,
-      FieldElement field,
-      Node initializer,
+  R visitTopLevelGetterGet(
+      Send node,
+      FunctionElement getter,
       A arg) {
-    apply(initializer, arg);
     return null;
   }
 
   @override
-  R visitGenerativeConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      NodeList initializers,
-      Node body,
+  R visitTopLevelGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
-    applyParameters(parameters, arg);
-    applyInitializers(initializers, arg);
-    apply(body, arg);
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitInstanceMethodDeclaration(
-      FunctionExpression node,
-      MethodElement method,
-      NodeList parameters,
-      Node body,
+  R visitTopLevelGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitLocalFunctionDeclaration(
-      FunctionExpression node,
-      LocalFunctionElement function,
-      NodeList parameters,
-      Node body,
+  R visitTopLevelGetterSetterPostfix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
     return null;
   }
 
   @override
-  R visitRedirectingFactoryConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      InterfaceType redirectionType,
-      ConstructorElement redirectionTarget,
+  R visitTopLevelGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    applyParameters(parameters, arg);
     return null;
   }
 
   @override
-  R visitRedirectingGenerativeConstructorDeclaration(
-      FunctionExpression node,
-      ConstructorElement constructor,
-      NodeList parameters,
-      NodeList initializers,
+  R visitTopLevelMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    applyParameters(parameters, arg);
-    applyInitializers(initializers, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
+  R visitTopLevelMethodSetterPostfix(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
     return null;
   }
 
   @override
-  R visitSuperConstructorInvoke(
+  R visitTopLevelMethodSetterPrefix(
       Send node,
-      ConstructorElement superConstructor,
-      InterfaceType type,
-      NodeList arguments,
-      Selector selector,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitThisConstructorInvoke(
-      Send node,
-      ConstructorElement thisConstructor,
-      NodeList arguments,
-      Selector selector,
+  R visitTopLevelSetterSet(
+      SendSet node,
+      FunctionElement setter,
+      Node rhs,
       A arg) {
-    apply(arguments, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTopLevelFunctionDeclaration(
-      FunctionExpression node,
-      MethodElement function,
-      NodeList parameters,
-      Node body,
+  R visitTypeVariableTypeLiteralCompound(
+      Send node,
+      TypeVariableElement element,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedFieldInitializer(
-      SendSet node,
-      Element element,
-      Node initializer,
+  R visitTypeVariableTypeLiteralGet(
+      Send node,
+      TypeVariableElement element,
       A arg) {
-    apply(initializer, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedSuperConstructorInvoke(
+  R visitTypeVariableTypeLiteralInvoke(
       Send node,
-      Element element,
+      TypeVariableElement element,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R errorUnresolvedThisConstructorInvoke(
+  R visitTypeVariableTypeLiteralPostfix(
       Send node,
-      Element element,
-      NodeList arguments,
-      Selector selector,
+      TypeVariableElement element,
+      IncDecOperator operator,
       A arg) {
-    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitLocalVariableDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
-      Node initializer,
+  R visitTypeVariableTypeLiteralPrefix(
+      Send node,
+      TypeVariableElement element,
+      IncDecOperator operator,
       A arg) {
-    if (initializer != null) {
-      apply(initializer, arg);
-    }
     return null;
   }
 
   @override
-  R visitOptionalParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      ConstantExpression defaultValue,
-      int index,
+  R visitTypedefTypeLiteralCompound(
+      Send node,
+      ConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      int index,
+  R visitTypedefTypeLiteralGet(
+      Send node,
+      ConstantExpression constant,
       A arg) {
     return null;
   }
 
   @override
-  R visitInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement initializingFormal,
-      int index,
+  R visitTypedefTypeLiteralInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
       A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitLocalConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      LocalVariableElement variable,
+  R visitTypedefTypeLiteralPostfix(
+      Send node,
       ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitNamedInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement initializingFormal,
-      ConstantExpression defaultValue,
+  R visitTypedefTypeLiteralPrefix(
+      Send node,
+      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitNamedParameterDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      ParameterElement parameter,
-      ConstantExpression defaultValue,
+  R visitUnary(
+      Send node,
+      UnaryOperator operator,
+      Node expression,
       A arg) {
+    apply(expression, arg);
     return null;
   }
 
   @override
-  R visitOptionalInitializingFormalDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      InitializingFormalElement initializingFormal,
-      ConstantExpression defaultValue,
-      int index,
+  R visitUnresolvedCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitInstanceFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
+  R visitUnresolvedGet(
+      Send node,
+      Element element,
       A arg) {
-    if (initializer != null) {
-      apply(initializer, arg);
-    }
     return null;
   }
 
   @override
-  R visitStaticConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      ConstantExpression constant,
+  R visitUnresolvedInvoke(
+      Send node,
+      Element element,
+      NodeList arguments,
+      Selector selector,
       A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitStaticFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
+  R visitUnresolvedPostfix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    if (initializer != null) {
-      apply(initializer, arg);
-    }
     return null;
   }
 
   @override
-  R visitTopLevelConstantDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      ConstantExpression constant,
+  R visitUnresolvedPrefix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
       A arg) {
     return null;
   }
 
   @override
-  R visitTopLevelFieldDeclaration(
-      VariableDefinitions node,
-      Node definition,
-      FieldElement field,
-      Node initializer,
+  R errorUnresolvedSet(
+      Send node,
+      Element element,
+      Node rhs,
       A arg) {
-    if (initializer != null) {
-      apply(initializer, arg);
-    }
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitAbstractGetterDeclaration(
-      FunctionExpression node,
+  R errorUndefinedBinaryExpression(
+      Send node,
+      Node left,
+      Operator operator,
+      Node right,
+      A arg) {
+    apply(left, arg);
+    apply(right, arg);
+    return null;
+  }
+
+  @override
+  R errorUndefinedUnaryExpression(
+      Send node,
+      Operator operator,
+      Node expression,
+      A arg) {
+    apply(expression, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperIndexSet(
+      Send node,
+      Element element,
+      Node index,
+      Node rhs,
+      A arg) {
+    apply(index, arg);
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperGetterCompoundIndexSet(
+      SendSet node,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(index, arg);
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterCompoundIndexSet(
+      SendSet node,
       MethodElement getter,
+      Element element,
+      Node index,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
+    apply(index, arg);
+    apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitAbstractSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
+  R visitUnresolvedSuperBinary(
+      Send node,
+      Element element,
+      BinaryOperator operator,
+      Node argument,
       A arg) {
-    applyParameters(parameters, arg);
+    apply(argument, arg);
     return null;
   }
 
   @override
-  R visitInstanceGetterDeclaration(
-      FunctionExpression node,
+  R visitUnresolvedSuperUnary(
+      Send node,
+      UnaryOperator operator,
+      Element element,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperGetterIndexPostfix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterIndexPostfix(
+      Send node,
       MethodElement getter,
-      Node body,
+      Element element,
+      Node index,
+      IncDecOperator operator,
       A arg) {
-    apply(body, arg);
+    apply(index, arg);
     return null;
   }
 
   @override
-  R visitInstanceSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitUnresolvedSuperGetterIndexPrefix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterIndexPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitIndexPostfix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitIndexPrefix(
+      Send node,
+      Node receiver,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperIndexPostfix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperIndexPrefix(
+      Send node,
+      FunctionElement indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      IncDecOperator operator,
+      A arg) {
+    apply(index, arg);
+    return null;
+  }
+
+  @override
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
+  R visitUnresolvedConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement element,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorNonConstantConstructorInvoke(
+      NewExpression node,
+      Element element,
+      InterfaceType type,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedStaticSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedTopLevelSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitFinalLocalVariablePostfix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitFinalLocalVariablePrefix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitFinalParameterPostfix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitFinalParameterPrefix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperFieldFieldCompound(
+      Send node, FieldElement readField,
+      FieldElement writtenField,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperFinalFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperMethodCompound(
+      Send node,
+      FunctionElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperMethodPostfix(
+      Send node,
+      FunctionElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitSuperMethodPrefix(
+      Send node,
+      FunctionElement method,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelMethodCompound(
+      Send node,
+      FunctionElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperPostfix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperPrefix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperGetterCompound(
+      Send node, Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterCompound(
+      Send node, MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    apply(rhs, arg);
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitUnresolvedSuperSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    return null;
+  }
+}
+
+/// [SemanticDeclarationVisitor] that visits subnodes.
+class TraversalDeclarationMixin<R, A>
+    implements SemanticDeclarationVisitor<R, A> {
+  @override
+  R apply(Node node, A arg) {
+    throw new UnimplementedError("TraversalMixin.apply unimplemented");
+  }
+
+  @override
+  applyInitializers(NodeList initializers, A arg) {
+    throw new UnimplementedError(
+        "TraversalMixin.applyInitializers unimplemented");
+  }
+
+  @override
+  applyParameters(NodeList parameters, A arg) {
+    throw new UnimplementedError(
+        "TraversalMixin.applyParameters unimplemented");
+  }
+
+  @override
+  R visitAbstractMethodDeclaration(
+      FunctionExpression node,
+      MethodElement method,
+      NodeList parameters,
+      A arg) {
+    applyParameters(parameters, arg);
+    return null;
+  }
+
+  @override
+  R visitClosureDeclaration(
+      FunctionExpression node,
+      LocalFunctionElement function,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitFactoryConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitFieldInitializer(
+      SendSet node,
+      FieldElement field,
+      Node initializer,
+      A arg) {
+    apply(initializer, arg);
+    return null;
+  }
+
+  @override
+  R visitGenerativeConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      NodeList initializers,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    applyInitializers(initializers, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitInstanceMethodDeclaration(
+      FunctionExpression node,
+      MethodElement method,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitLocalFunctionDeclaration(
+      FunctionExpression node,
+      LocalFunctionElement function,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingFactoryConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      InterfaceType redirectionType,
+      ConstructorElement redirectionTarget,
+      A arg) {
+    applyParameters(parameters, arg);
+    return null;
+  }
+
+  @override
+  R visitRedirectingGenerativeConstructorDeclaration(
+      FunctionExpression node,
+      ConstructorElement constructor,
+      NodeList parameters,
+      NodeList initializers,
+      A arg) {
+    applyParameters(parameters, arg);
+    applyInitializers(initializers, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticFunctionDeclaration(
+      FunctionExpression node,
+      MethodElement function,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitSuperConstructorInvoke(
+      Send node,
+      ConstructorElement superConstructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitThisConstructorInvoke(
+      Send node,
+      ConstructorElement thisConstructor,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitTopLevelFunctionDeclaration(
+      FunctionExpression node,
+      MethodElement function,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R errorUnresolvedFieldInitializer(
+      SendSet node,
+      Element element,
+      Node initializer,
+      A arg) {
+    apply(initializer, arg);
+    return null;
+  }
+
+  @override
+  R errorUnresolvedSuperConstructorInvoke(
+      Send node,
+      Element element,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R errorUnresolvedThisConstructorInvoke(
+      Send node,
+      Element element,
+      NodeList arguments,
+      Selector selector,
+      A arg) {
+    apply(arguments, arg);
+    return null;
+  }
+
+  @override
+  R visitLocalVariableDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      LocalVariableElement variable,
+      Node initializer,
+      A arg) {
+    if (initializer != null) {
+      apply(initializer, arg);
+    }
+    return null;
+  }
+
+  @override
+  R visitOptionalParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      ConstantExpression defaultValue,
+      int index,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      int index,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement initializingFormal,
+      int index,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitLocalConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      LocalVariableElement variable,
+      ConstantExpression constant,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitNamedInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement initializingFormal,
+      ConstantExpression defaultValue,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitNamedParameterDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      ParameterElement parameter,
+      ConstantExpression defaultValue,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitOptionalInitializingFormalDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      InitializingFormalElement initializingFormal,
+      ConstantExpression defaultValue,
+      int index,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitInstanceFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
+      A arg) {
+    if (initializer != null) {
+      apply(initializer, arg);
+    }
+    return null;
+  }
+
+  @override
+  R visitStaticConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      ConstantExpression constant,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitStaticFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
+      A arg) {
+    if (initializer != null) {
+      apply(initializer, arg);
+    }
+    return null;
+  }
+
+  @override
+  R visitTopLevelConstantDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      ConstantExpression constant,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitTopLevelFieldDeclaration(
+      VariableDefinitions node,
+      Node definition,
+      FieldElement field,
+      Node initializer,
+      A arg) {
+    if (initializer != null) {
+      apply(initializer, arg);
+    }
+    return null;
+  }
+
+  @override
+  R visitAbstractGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      A arg) {
+    return null;
+  }
+
+  @override
+  R visitAbstractSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      A arg) {
+    applyParameters(parameters, arg);
+    return null;
+  }
+
+  @override
+  R visitInstanceGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
+      A arg) {
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitInstanceSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
+      A arg) {
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitStaticSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitTopLevelGetterDeclaration(
+      FunctionExpression node,
+      MethodElement getter,
+      Node body,
+      A arg) {
+    apply(body, arg);
+    return null;
+  }
+
+  @override
+  R visitTopLevelSetterDeclaration(
+      FunctionExpression node,
+      MethodElement setter,
+      NodeList parameters,
+      Node body,
+      A arg) {
+    applyParameters(parameters, arg);
+    apply(body, arg);
+    return null;
+  }
+}
+
+/// AST visitor that visits all normal [Send] and [SendSet] nodes using the
+/// [SemanticVisitor].
+class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
+    with TraversalSendMixin<R, A>,
+         TraversalDeclarationMixin<R, A> {
+  TraversalVisitor(TreeElements elements) : super(elements);
+
+  SemanticSendVisitor<R, A> get sendVisitor => this;
+
+  SemanticDeclarationVisitor<R, A> get declVisitor => this;
+
+  R apply(Node node, A arg) {
+    node.accept(this);
+    return null;
+  }
+
+  @override
+  applyInitializers(NodeList initializers, A arg) {
+    visitInitializers(initializers, arg);
+  }
+
+  @override
+  applyParameters(NodeList parameters, A arg) {
+    visitParameters(parameters, arg);
+  }
+
+  @override
+  internalError(Spannable spannable, String message) {
+    throw new SpannableAssertionFailure(spannable, message);
+  }
+
+  @override
+  R visitNode(Node node) {
+    node.visitChildren(this);
+    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 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,
+      A arg);
+
+  R handleStaticFieldInvoke(
+      Send node,
+      FieldElement field,
+      NodeList arguments,
+      CallStructure callStructure,
+      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,
+      CallStructure callStructure,
+      A arg);
+
+  R handleStaticFunctionIncompatibleInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg);
+
+  R handleStaticGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg);
+
+  R handleStaticGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
+      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,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFieldInvoke(node, field, arguments, callStructure, 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,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFunctionInvoke(
+        node, function, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitStaticFunctionIncompatibleInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFunctionIncompatibleInvoke(
+        node, function, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitStaticGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg) {
+    return handleStaticGetterGet(node, getter, arg);
+  }
+
+  @override
+  R visitStaticGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticGetterInvoke(
+        node, getter, arguments, callStructure, 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,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFieldInvoke(node, field, arguments, callStructure, 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,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFunctionInvoke(
+        node, function, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitTopLevelFunctionIncompatibleInvoke(
+      Send node,
+      MethodElement function,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticFunctionIncompatibleInvoke(
+        node, function, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitTopLevelGetterGet(
+      Send node,
+      FunctionElement getter,
+      A arg) {
+    return handleStaticGetterGet(node, getter, arg);
+  }
+
+  @override
+  R visitTopLevelGetterInvoke(
+      Send node,
+      FunctionElement getter,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleStaticGetterInvoke(
+        node, getter, arguments, callStructure, 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 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,
+      A arg);
+
+  R handleLocalInvoke(
+      Send node,
+      LocalElement element,
+      NodeList arguments,
+      CallStructure callStructure,
+      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,
+      CallStructure callStructure,
+      A arg) {
+    return handleLocalInvoke(node, function, arguments, callStructure, 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,
+      CallStructure callStructure,
+      A arg) {
+    return handleLocalInvoke(node, variable, arguments, callStructure, 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,
+      CallStructure callStructure,
+      A arg) {
+    return handleLocalInvoke(node, parameter, arguments, callStructure, 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 BaseImplementationOfConstantsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
+  R handleConstantGet(
+      Node node,
+      ConstantExpression constant,
+      A arg);
+
+  R handleConstantInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg);
+
+  @override
+  R visitClassTypeLiteralGet(
+      Send node,
+      ConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitClassTypeLiteralInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitConstantGet(
+      Send node,
+      ConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitConstantInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitDynamicTypeLiteralGet(
+      Send node,
+      ConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitDynamicTypeLiteralInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitTypedefTypeLiteralGet(
+      Send node,
+      ConstantExpression constant,
+      A arg) {
+    return handleConstantGet(node, constant, arg);
+  }
+
+  @override
+  R visitTypedefTypeLiteralInvoke(
+      Send node,
+      ConstantExpression constant,
+      NodeList arguments,
+      CallStructure callStructure,
+      A arg) {
+    return handleConstantInvoke(node, constant, arguments, callStructure, 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 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(
+      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);
+
+  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(
+        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);
+  }
+
+  @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);
+  }
+}
+
+/// The getter kind for statically resolved compound expressions.
+enum CompoundGetter {
+  /// The compound reads from a field.
+  FIELD,
+
+  /// The compound reads from a getter.
+  GETTER,
+
+  /// The compound reads (closurizes) a method.
+  METHOD,
+
+  /// The getter is unresolved. The accompanied element is an erroneous element.
+  UNRESOLVED,
+}
+
+/// The setter kind for statically resolved compound expressions.
+enum CompoundSetter {
+  /// The compound writes to a field.
+  FIELD,
+
+  /// The compound writes to a setter.
+  SETTER,
+
+  /// The setter is unresolved or unassignable. The accompanied element may be
+  /// `null`, and erroneous element, or the unassignable element.
+  INVALID,
+}
+
+/// The kind of a [CompoundRhs].
+enum CompoundKind {
+  /// A prefix expression, like `--a`.
+  PREFIX,
+
+  /// A postfix expression, like `a++`.
+  POSTFIX,
+
+  /// A compound assignment, like `a *= b`.
+  ASSIGNMENT,
+}
+
+/// The right-hand side of a compound expression.
+abstract class CompoundRhs {
+  /// The kind of compound.
+  CompoundKind get kind;
+
+  /// The binary operator implied by the compound operator.
+  BinaryOperator get operator;
+
+  /// The explicit right hand side in case of a compound assignment, `null`
+  /// otherwise.
+  Node get rhs;
+}
+
+/// A prefix or postfix of [incDecOperator].
+class IncDecCompound implements CompoundRhs {
+  final CompoundKind kind;
+  final IncDecOperator incDecOperator;
+
+  IncDecCompound(this.kind, this.incDecOperator);
+
+  BinaryOperator get operator => incDecOperator.binaryOperator;
+
+  Node get rhs => null;
+}
+
+/// A compound assignment with [assignmentOperator] and [rhs].
+class AssignmentCompound implements CompoundRhs {
+  final AssignmentOperator assignmentOperator;
+  final Node rhs;
+
+  AssignmentCompound(this.assignmentOperator, this.rhs);
+
+  CompoundKind get kind => CompoundKind.ASSIGNMENT;
+
+  BinaryOperator get operator => assignmentOperator.binaryOperator;
+}
+
+/// Simplified handling of compound assignments and prefix/postfix expressions.
+abstract class BaseImplementationOfCompoundsMixin<R, A>
+    implements SemanticSendVisitor<R, A> {
+
+  /// Handle a super compound, like `super.foo += 42` or `--super.bar`.
+  R handleSuperCompound(
+      SendSet node,
+      Element getter,
+      CompoundGetter getterKind,
+      Element setter,
+      CompoundSetter setterKind,
+      CompoundRhs rhs,
+      A arg);
+
+  /// Handle a static or top level compound, like `foo += 42` or `--bar`.
+  R handleStaticCompound(
+      SendSet node,
+      Element getter,
+      CompoundGetter getterKind,
+      Element setter,
+      CompoundSetter setterKind,
+      CompoundRhs rhs,
+      A arg);
+
+  /// Handle a local compound, like `foo += 42` or `--bar`. If [isSetterValid]
+  /// is false [local] is unassignable.
+  R handleLocalCompound(
+      SendSet node,
+      LocalElement local,
+      CompoundRhs rhs,
+      A arg,
+      {bool isSetterValid});
+
+  /// Handle a compound on a constant, like `Object += 42` or `--Object`.
+  R handleConstantCompound(
+      SendSet node,
+      ConstantExpression constant,
+      CompoundRhs rhs,
+      A arg);
+
+  /// Handle a compound on a type variable type literal, like `T += 42` or
+  /// `--T`.
+  R handleTypeVariableTypeLiteralCompound(
+      SendSet node,
+      TypeVariableElement typeVariable,
+      CompoundRhs rhs,
+      A arg);
+
+  /// Handle a dynamic compound, like `o.foo += 42` or `--o.foo`. [receiver] is
+  /// `null` for properties on `this`, like `--this.foo` or `--foo`.
+  R handleDynamicCompound(
+      Send node,
+      Node receiver,
+      CompoundRhs rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg);
+
+  R visitDynamicPropertyCompound(
+      Send node,
+      Node receiver,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node,
+        receiver,
+        new AssignmentCompound(operator, rhs),
+        getterSelector,
+        setterSelector,
+        arg);
+  }
+
+  @override
+  R visitThisPropertyCompound(
+      Send node,
+      AssignmentOperator operator,
+      Node rhs,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node,
+        null,
+        new AssignmentCompound(operator, rhs),
+        getterSelector,
+        setterSelector,
+        arg);
+  }
+
+  @override
+  R visitParameterCompound(
+      Send node,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleLocalCompound(
+        node,
+        parameter,
+        new AssignmentCompound(operator, rhs),
+        arg,
+        isSetterValid: true);
+  }
+
+  @override
+  R visitFinalParameterCompound(
+      Send node,
+      ParameterElement parameter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    apply(body, arg);
-    return null;
+    return handleLocalCompound(
+        node,
+        parameter,
+        new AssignmentCompound(operator, rhs),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitStaticSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitLocalVariableCompound(
+      Send node,
+      LocalVariableElement variable,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
-    return null;
+    return handleLocalCompound(
+        node,
+        variable,
+        new AssignmentCompound(operator, rhs),
+        arg,
+        isSetterValid: true);
   }
 
   @override
-  R visitTopLevelGetterDeclaration(
-      FunctionExpression node,
-      MethodElement getter,
-      Node body,
+  R visitFinalLocalVariableCompound(
+      Send node,
+      LocalVariableElement variable,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    apply(body, arg);
-    return null;
+    return handleLocalCompound(
+        node,
+        variable,
+        new AssignmentCompound(operator, rhs),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitTopLevelSetterDeclaration(
-      FunctionExpression node,
-      MethodElement setter,
-      NodeList parameters,
-      Node body,
+  R visitLocalFunctionCompound(
+      Send node,
+      LocalFunctionElement function,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    applyParameters(parameters, arg);
-    apply(body, arg);
-    return null;
+    return handleLocalCompound(
+        node,
+        function,
+        new AssignmentCompound(operator, rhs),
+        arg,
+        isSetterValid: false);
   }
-}
 
-/// AST visitor that visits all normal [Send] and [SendSet] nodes using the
-/// [SemanticVisitor].
-class TraversalVisitor<R, A> extends SemanticVisitor<R, A>
-    with TraversalSendMixin<R, A>,
-         TraversalDeclarationMixin<R, A> {
-  TraversalVisitor(TreeElements elements) : super(elements);
-
-  SemanticSendVisitor<R, A> get sendVisitor => this;
-
-  SemanticDeclarationVisitor<R, A> get declVisitor => this;
-
-  R apply(Node node, A arg) {
-    node.accept(this);
-    return null;
+  @override
+  R visitStaticFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  applyInitializers(NodeList initializers, A arg) {
-    visitInitializers(initializers, arg);
+  R visitStaticFinalFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        null, CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  applyParameters(NodeList parameters, A arg) {
-    visitParameters(parameters, arg);
+  R visitStaticGetterSetterCompound(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  internalError(Spannable spannable, String message) {
-    throw new SpannableAssertionFailure(spannable, message);
+  R visitStaticMethodSetterCompound(
+      Send node,
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitNode(Node node) {
-    node.visitChildren(this);
-    return null;
+  R visitTopLevelFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
-}
 
-/// 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 BaseImplementationOfStaticsMixin<R, A>
-    implements SemanticSendVisitor<R, A> {
-  R handleStaticFieldCompound(
+  @override
+  R visitTopLevelFinalFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
-      A arg);
+      A arg) {
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        null, CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFieldGet(
+  @override
+  R visitTopLevelGetterSetterCompound(
       Send node,
-      FieldElement field,
-      A arg);
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFieldInvoke(
+  @override
+  R visitTopLevelMethodSetterCompound(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFieldPostfixPrefix(
+  @override
+  R visitSuperFieldCompound(
       Send node,
       FieldElement field,
-      IncDecOperator operator,
-      A arg,
-      {bool isPrefix});
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFieldSet(
-      SendSet node,
+  @override
+  R visitSuperFinalFieldCompound(
+      Send node,
       FieldElement field,
+      AssignmentOperator operator,
       Node rhs,
-      A arg);
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFunctionGet(
+  @override
+  R visitSuperGetterSetterCompound(
       Send node,
-      MethodElement function,
-      A arg);
+      FunctionElement getter,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFunctionInvoke(
+  @override
+  R visitSuperMethodSetterCompound(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      FunctionElement method,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticFunctionIncompatibleInvoke(
+  @override
+  R visitSuperFieldSetterCompound(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      FieldElement field,
+      FunctionElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        setter, CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticGetterGet(
+  @override
+  R visitSuperGetterFieldCompound(
       Send node,
       FunctionElement getter,
-      A arg);
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        field, CompoundSetter.FIELD,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticGetterInvoke(
+  @override
+  R visitClassTypeLiteralCompound(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      ConstantExpression constant,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleConstantCompound(
+        node,
+        constant,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticGetterSetterCompound(
+  @override
+  R visitTypedefTypeLiteralCompound(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
-      A arg);
+      A arg) {
+    return handleConstantCompound(
+        node,
+        constant,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticGetterSetterPostfixPrefix(
+  @override
+  R visitTypeVariableTypeLiteralCompound(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
-      IncDecOperator operator,
-      A arg,
-      {bool isPrefix});
+      TypeVariableElement element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleTypeVariableTypeLiteralCompound(
+        node,
+        element,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleStaticMethodSetterCompound(
+  @override
+  R visitDynamicTypeLiteralCompound(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
-      A arg);
+      A arg) {
+    return handleConstantCompound(
+        node,
+        constant,
+        new AssignmentCompound(operator, rhs),
+        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);
+  R visitDynamicPropertyPrefix(
+      Send node,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node,
+        receiver,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        getterSelector,
+        setterSelector,
+        arg);
+  }
 
   @override
-  R visitStaticFieldCompound(
+  R visitParameterPrefix(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      ParameterElement parameter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldCompound(node, field, operator, rhs, arg);
+    return handleLocalCompound(
+        node,
+        parameter,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg,
+        isSetterValid: true);
   }
 
   @override
-  R visitStaticFieldGet(
+  R visitLocalVariablePrefix(
       Send node,
-      FieldElement field,
+      LocalVariableElement variable,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldGet(node, field, arg);
+    return handleLocalCompound(
+        node,
+        variable,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg,
+        isSetterValid: true);
   }
 
   @override
-  R visitStaticFieldInvoke(
+  R visitLocalFunctionPrefix(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      LocalFunctionElement function,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
+    return handleLocalCompound(
+        node,
+        function,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg,
+        isSetterValid: false);
   }
 
-  @override
-  R visitStaticFieldPostfix(
+
+  R visitThisPropertyPrefix(
       Send node,
-      FieldElement field,
       IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    return handleStaticFieldPostfixPrefix(
-        node, field, operator, arg, isPrefix: false);
+    return handleDynamicCompound(
+        node,
+        null,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        getterSelector,
+        setterSelector,
+        arg);
   }
 
   @override
@@ -5615,805 +7832,1257 @@ abstract class BaseImplementationOfStaticsMixin<R, A>
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return handleStaticFieldPostfixPrefix(
-        node, field, operator, arg, isPrefix: true);
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
+  R visitStaticGetterSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldSet(node, field, rhs, arg);
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
+  }
+
+
+  R visitStaticMethodSetterPrefix(
+      Send node,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticFunctionGet(
+  R visitTopLevelFieldPrefix(
       Send node,
-      MethodElement function,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionGet(node, function, arg);
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticFunctionInvoke(
+  R visitTopLevelGetterSetterPrefix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionInvoke(
-        node, function, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticFunctionIncompatibleInvoke(
+  R visitTopLevelMethodSetterPrefix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionIncompatibleInvoke(
-        node, function, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticGetterGet(
+  R visitSuperFieldPrefix(
       Send node,
-      FunctionElement getter,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterGet(node, getter, arg);
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticGetterInvoke(
+  R visitSuperFieldFieldPrefix(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterInvoke(
-        node, getter, arguments, callStructure, arg);
+    return handleSuperCompound(
+        node,
+        readField, CompoundGetter.FIELD,
+        writtenField, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticGetterSetterCompound(
+  R visitSuperFieldSetterPrefix(
       Send node,
-      FunctionElement getter,
+      FieldElement field,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterCompound(
-        node, getter, setter, operator, rhs, arg);
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
-  @override
-  R visitStaticGetterSetterPostfix(
+
+  R visitSuperGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: false);
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticGetterSetterPrefix(
+  R visitSuperGetterFieldPrefix(
       Send node,
       FunctionElement getter,
-      FunctionElement setter,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: true);
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticMethodSetterCompound(
+  R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterCompound(
-        node, method, setter, operator, rhs, arg);
+    return handleSuperCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticMethodSetterPostfix(
+  R visitClassTypeLiteralPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: false);
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticMethodSetterPrefix(
+  R visitTypedefTypeLiteralPrefix(
       Send node,
-      FunctionElement getter,
-      FunctionElement setter,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: true);
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitStaticSetterSet(
-      SendSet node,
-      FunctionElement setter,
-      Node rhs,
+  R visitTypeVariableTypeLiteralPrefix(
+      Send node,
+      TypeVariableElement element,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticSetterSet(node, setter, rhs, arg);
+    return handleTypeVariableTypeLiteralCompound(
+        node,
+        element,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelFieldCompound(
+  R visitDynamicTypeLiteralPrefix(
       Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
+      ConstantExpression constant,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldCompound(node, field, operator, rhs, arg);
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelFieldGet(
+  R visitDynamicPropertyPostfix(
       Send node,
-      FieldElement field,
+      Node receiver,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
       A arg) {
-    return handleStaticFieldGet(node, field, arg);
+    return handleDynamicCompound(
+        node,
+        receiver,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        getterSelector,
+        setterSelector,
+        arg);
   }
 
   @override
-  R visitTopLevelFieldInvoke(
+  R visitParameterPostfix(
       Send node,
-      FieldElement field,
-      NodeList arguments,
-      CallStructure callStructure,
+      ParameterElement parameter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldInvoke(node, field, arguments, callStructure, arg);
+    return handleLocalCompound(
+        node,
+        parameter,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg,
+        isSetterValid: true);
   }
 
   @override
-  R visitTopLevelFieldPostfix(
+  R visitLocalVariablePostfix(
       Send node,
-      FieldElement field,
+      LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
-    return handleStaticFieldPostfixPrefix(
-        node, field, operator, arg, isPrefix: false);
+    return handleLocalCompound(
+        node,
+        variable,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg,
+        isSetterValid: true);
   }
 
   @override
-  R visitTopLevelFieldPrefix(
+  R visitLocalFunctionPostfix(
       Send node,
-      FieldElement field,
+      LocalFunctionElement function,
       IncDecOperator operator,
       A arg) {
-    return handleStaticFieldPostfixPrefix(
-        node, field, operator, arg, isPrefix: true);
+    return handleLocalCompound(
+        node,
+        function,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg,
+        isSetterValid: false);
+  }
+
+
+  R visitThisPropertyPostfix(
+      Send node,
+      IncDecOperator operator,
+      Selector getterSelector,
+      Selector setterSelector,
+      A arg) {
+    return handleDynamicCompound(
+        node,
+        null,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        getterSelector,
+        setterSelector,
+        arg);
   }
 
   @override
-  R visitTopLevelFieldSet(
-      SendSet node,
+  R visitStaticFieldPostfix(
+      Send node,
       FieldElement field,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFieldSet(node, field, rhs, arg);
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelFunctionGet(
+  R visitStaticGetterSetterPostfix(
       Send node,
-      MethodElement function,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionGet(node, function, arg);
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
-  @override
-  R visitTopLevelFunctionInvoke(
+
+  R visitStaticMethodSetterPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionInvoke(
-        node, function, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelFunctionIncompatibleInvoke(
+  R visitTopLevelFieldPostfix(
       Send node,
-      MethodElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticFunctionIncompatibleInvoke(
-        node, function, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelGetterGet(
+  R visitTopLevelGetterSetterPostfix(
       Send node,
       FunctionElement getter,
+      FunctionElement setter,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterGet(node, getter, arg);
+    return handleStaticCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelGetterInvoke(
+  R visitTopLevelMethodSetterPostfix(
       Send node,
-      FunctionElement getter,
-      NodeList arguments,
-      CallStructure callStructure,
+      FunctionElement method,
+      FunctionElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
+
+  @override
+  R visitSuperFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
+
+  @override
+  R visitSuperFieldFieldPostfix(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterInvoke(
-        node, getter, arguments, callStructure, arg);
+    return handleSuperCompound(
+        node,
+        readField, CompoundGetter.FIELD,
+        writtenField, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelGetterSetterCompound(
+  R visitSuperFieldSetterPostfix(
       Send node,
-      FunctionElement getter,
+      FieldElement field,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterCompound(
-        node, getter, setter, operator, rhs, arg);
+    return handleSuperCompound(
+        node,
+        field, CompoundGetter.FIELD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
-  @override
-  R visitTopLevelGetterSetterPostfix(
+
+  R visitSuperGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: false);
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelGetterSetterPrefix(
+  R visitSuperGetterFieldPostfix(
       Send node,
       FunctionElement getter,
-      FunctionElement setter,
+      FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return handleStaticGetterSetterPostfixPrefix(
-        node, getter, setter, operator, arg, isPrefix: true);
+    return handleSuperCompound(
+        node,
+        getter, CompoundGetter.GETTER,
+        field, CompoundSetter.FIELD,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelMethodSetterCompound(
+  R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterCompound(
-        node, method, setter, operator, rhs, arg);
+    return handleSuperCompound(
+        node,
+        method, CompoundGetter.METHOD,
+        setter, CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelMethodSetterPostfix(
+  R visitClassTypeLiteralPostfix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterPostfixPrefix(
-        node, method, setter, operator, arg, isPrefix: false);
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelMethodSetterPrefix(
+  R visitTypedefTypeLiteralPostfix(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      ConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return handleStaticMethodSetterPostfixPrefix(
-        node, method, setter, operator, arg, isPrefix: true);
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTopLevelSetterSet(
-      SendSet node,
-      FunctionElement setter,
-      Node rhs,
+  R visitTypeVariableTypeLiteralPostfix(
+      Send node,
+      TypeVariableElement element,
+      IncDecOperator operator,
       A arg) {
-    return handleStaticSetterSet(node, setter, rhs, arg);
+    return handleTypeVariableTypeLiteralCompound(
+        node,
+        element,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        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 BaseImplementationOfLocalsMixin<R, A>
-    implements SemanticSendVisitor<R, A> {
-  R handleLocalCompound(
-      Send node,
-      LocalElement element,
-      AssignmentOperator operator,
-      Node rhs,
-      A arg);
 
-  R handleLocalGet(
+  @override
+  R visitDynamicTypeLiteralPostfix(
       Send node,
-      LocalElement element,
-      A arg);
+      ConstantExpression constant,
+      IncDecOperator operator,
+      A arg) {
+    return handleConstantCompound(
+        node,
+        constant,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
 
-  R handleLocalInvoke(
+  @override
+  R visitUnresolvedStaticGetterPostfix(
       Send node,
-      LocalElement element,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
 
-  R handleLocalPostfixPrefix(
+  @override
+  R visitUnresolvedTopLevelGetterPostfix(
       Send node,
-      LocalElement element,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
-      A arg,
-      {bool isPrefix});
-
-  R handleLocalSet(
-      SendSet node,
-      LocalElement element,
-      Node rhs,
-      A arg);
+      A arg) {
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
 
   @override
-  R visitLocalFunctionGet(
+  R visitUnresolvedStaticSetterPostfix(
       Send node,
-      LocalFunctionElement function,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalGet(node, function, arg);
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalFunctionInvoke(
+  R visitUnresolvedTopLevelSetterPostfix(
       Send node,
-      LocalFunctionElement function,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalInvoke(node, function, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariableCompound(
+  R visitStaticMethodPostfix(
       Send node,
-      LocalVariableElement variable,
-      AssignmentOperator operator,
-      Node rhs,
+      MethodElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalCompound(node, variable, operator, rhs, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariableGet(
+  R visitTopLevelMethodPostfix(
       Send node,
-      LocalVariableElement variable,
+      MethodElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalGet(node, variable, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariableInvoke(
+  R visitUnresolvedPostfix(
       Send node,
-      LocalVariableElement variable,
-      NodeList arguments,
-      CallStructure callStructure,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalInvoke(node, variable, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariablePostfix(
+  R visitUnresolvedStaticGetterPrefix(
       Send node,
-      LocalVariableElement variable,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
       A arg) {
-    return handleLocalPostfixPrefix(
-        node, variable, operator, arg, isPrefix: false);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariablePrefix(
+  R visitUnresolvedTopLevelGetterPrefix(
       Send node,
-      LocalVariableElement variable,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
       A arg) {
-    return handleLocalPostfixPrefix(
-        node, variable, operator, arg, isPrefix: true);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
+  R visitUnresolvedStaticSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalSet(node, variable, rhs, arg);
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitParameterCompound(
+  R visitUnresolvedTopLevelSetterPrefix(
       Send node,
-      ParameterElement parameter,
-      AssignmentOperator operator,
-      Node rhs,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalCompound(node, parameter, operator, rhs, arg);
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitParameterGet(
+  R visitStaticMethodPrefix(
       Send node,
-      ParameterElement parameter,
+      MethodElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalGet(node, parameter, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitParameterInvoke(
+  R visitTopLevelMethodPrefix(
       Send node,
-      ParameterElement parameter,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleLocalInvoke(node, parameter, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitParameterPostfix(
+  R visitUnresolvedPrefix(
       Send node,
-      ParameterElement parameter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return handleLocalPostfixPrefix(
-        node, parameter, operator, arg, isPrefix: false);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitParameterPrefix(
+  R visitUnresolvedStaticGetterCompound(
       Send node,
-      ParameterElement parameter,
-      IncDecOperator operator,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return handleLocalPostfixPrefix(
-        node, parameter, operator, arg, isPrefix: true);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitParameterSet(
-      SendSet node,
-      ParameterElement parameter,
+  R visitUnresolvedTopLevelGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return handleLocalSet(node, parameter, rhs, arg);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new AssignmentCompound(operator, 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 BaseImplementationOfConstantsMixin<R, A>
-    implements SemanticSendVisitor<R, A> {
-  R handleConstantGet(
-      Node node,
-      ConstantExpression constant,
-      A arg);
+  @override
+  R visitUnresolvedStaticSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleConstantInvoke(
+  @override
+  R visitUnresolvedTopLevelSetterCompound(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      A arg);
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg) {
+    return handleStaticCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
   @override
-  R visitClassTypeLiteralGet(
+  R visitStaticMethodCompound(
       Send node,
-      ConstantExpression constant,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return handleConstantGet(node, constant, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitClassTypeLiteralInvoke(
+  R visitTopLevelMethodCompound(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitConstConstructorInvoke(
-      NewExpression node,
-      ConstructedConstantExpression constant,
+  R visitUnresolvedCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return handleConstantGet(node, constant, arg);
+    return handleStaticCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitConstantGet(
+  R visitFinalLocalVariablePostfix(
       Send node,
-      ConstantExpression constant,
+      LocalVariableElement variable,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantGet(node, constant, arg);
+    return handleLocalCompound(
+        node,
+        variable,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitConstantInvoke(
+  R visitFinalLocalVariablePrefix(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      LocalVariableElement variable,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+    return handleLocalCompound(
+        node,
+        variable,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitDynamicTypeLiteralGet(
+  R visitFinalParameterPostfix(
       Send node,
-      ConstantExpression constant,
+      ParameterElement parameter,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantGet(node, constant, arg);
+    return handleLocalCompound(
+        node,
+        parameter,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitDynamicTypeLiteralInvoke(
+  R visitFinalParameterPrefix(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      ParameterElement parameter,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+    return handleLocalCompound(
+        node,
+        parameter,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg,
+        isSetterValid: false);
   }
 
   @override
-  R visitTypedefTypeLiteralGet(
+  R visitStaticFinalFieldPostfix(
       Send node,
-      ConstantExpression constant,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantGet(node, constant, arg);
+    return handleStaticCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitTypedefTypeLiteralInvoke(
+  R visitStaticFinalFieldPrefix(
       Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
+      FieldElement field,
+      IncDecOperator operator,
       A arg) {
-    return handleConstantInvoke(node, constant, arguments, callStructure, arg);
+    return handleStaticCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        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 BaseImplementationOfDynamicsMixin<R, A>
-    implements SemanticSendVisitor<R, A> {
-  R handleDynamicCompound(
+  @override
+  R visitSuperFieldFieldCompound(
       Send node,
-      Node receiver,
+      FieldElement readField,
+      FieldElement writtenField,
       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);
+      A arg) {
+    return handleSuperCompound(
+        node,
+        readField,
+        CompoundGetter.FIELD,
+        writtenField,
+        CompoundSetter.FIELD,
+        new AssignmentCompound(operator, rhs),
+        arg);
+  }
 
-  R handleDynamicPostfixPrefix(
+  @override
+  R visitSuperFinalFieldPostfix(
       Send node,
-      Node receiver,
+      FieldElement field,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
-      A arg,
-      {bool isPrefix});
-
-  R handleDynamicSet(
-      SendSet node,
-      Node receiver,
-      Selector selector,
-      Node rhs,
-      A arg);
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
+  }
 
-  R handleDynamicIndexPostfixPrefix(
+  @override
+  R visitSuperFinalFieldPrefix(
       Send node,
-      Node receiver,
-      Node index,
+      FieldElement field,
       IncDecOperator operator,
-      A arg,
-      {bool isPrefix});
+      A arg) {
+    return handleSuperCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
+  }
 
   @override
-  R visitDynamicPropertyCompound(
+  R visitSuperMethodCompound(
       Send node,
-      Node receiver,
+      FunctionElement method,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicCompound(
-        node, receiver, operator, rhs, getterSelector, setterSelector, arg);
+    return handleSuperCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitDynamicPropertyGet(
+  R visitSuperMethodPostfix(
       Send node,
-      Node receiver,
-      Selector selector,
+      FunctionElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleDynamicGet(node, receiver, selector, arg);
+    return handleSuperCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitDynamicPropertyInvoke(
+  R visitSuperMethodPrefix(
       Send node,
-      Node receiver,
-      NodeList arguments,
-      Selector selector,
+      FunctionElement method,
+      IncDecOperator operator,
       A arg) {
-    return handleDynamicInvoke(node, receiver, arguments, selector, arg);
+    return handleSuperCompound(
+        node,
+        method,
+        CompoundGetter.METHOD,
+        method,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitDynamicPropertyPostfix(
+  R visitTopLevelFinalFieldPostfix(
       Send node,
-      Node receiver,
+      FieldElement field,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: false);
+    return handleStaticCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitDynamicPropertyPrefix(
+  R visitTopLevelFinalFieldPrefix(
       Send node,
-      Node receiver,
+      FieldElement field,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: true);
+    return handleStaticCompound(
+        node,
+        field,
+        CompoundGetter.FIELD,
+        field,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitDynamicPropertySet(
-      SendSet node,
-      Node receiver,
-      Selector selector,
+  R visitUnresolvedSuperCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return handleDynamicSet(node, receiver, selector, rhs, arg);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitThisPropertyCompound(
+  R visitUnresolvedSuperPostfix(
       Send node,
-      AssignmentOperator operator,
-      Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleDynamicCompound(
-        node, null, operator, rhs, getterSelector, setterSelector, arg);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitThisPropertyGet(
+  R visitUnresolvedSuperPrefix(
       Send node,
-      Selector selector,
+      Element element,
+      IncDecOperator operator,
       A arg) {
-    return handleDynamicGet(node, null, selector, arg);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitThisPropertyInvoke(
-      Send node,
-      NodeList arguments,
-      Selector selector,
+  R visitUnresolvedSuperGetterCompound(
+      Send node, Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
       A arg) {
-    return handleDynamicInvoke(node, null, arguments, selector, arg);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitThisPropertyPostfix(
+  R visitUnresolvedSuperGetterPostfix(
       Send node,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicPostfixPrefix(
-        node, null, operator,
-        getterSelector, setterSelector, arg, isPrefix: false);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitThisPropertyPrefix(
+  R visitUnresolvedSuperGetterPrefix(
       Send node,
+      Element element,
+      MethodElement setter,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicPostfixPrefix(
-        node, null, operator,
-        getterSelector, setterSelector, arg, isPrefix: true);
+    return handleSuperCompound(
+        node,
+        element,
+        CompoundGetter.UNRESOLVED,
+        setter,
+        CompoundSetter.SETTER,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 
   @override
-  R visitThisPropertySet(
-      SendSet node,
-      Selector selector,
+  R visitUnresolvedSuperSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return handleDynamicSet(node, null, selector, rhs, arg);
+    return handleSuperCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new AssignmentCompound(operator, rhs),
+        arg);
   }
 
   @override
-  R visitIndexPostfix(
+  R visitUnresolvedSuperSetterPostfix(
       Send node,
-      Node receiver,
-      Node index,
+      MethodElement getter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return handleDynamicIndexPostfixPrefix(
-        node, receiver, index, operator, arg, isPrefix: false);
+    return handleSuperCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.POSTFIX, operator),
+        arg);
   }
 
   @override
-  R visitIndexPrefix(
+  R visitUnresolvedSuperSetterPrefix(
       Send node,
-      Node receiver,
-      Node index,
+      MethodElement getter,
+      Element element,
       IncDecOperator operator,
       A arg) {
-    return handleDynamicIndexPostfixPrefix(
-        node, receiver, index, operator, arg, isPrefix: true);
+    return handleSuperCompound(
+        node,
+        getter,
+        CompoundGetter.GETTER,
+        element,
+        CompoundSetter.INVALID,
+        new IncDecCompound(CompoundKind.PREFIX, operator),
+        arg);
   }
 }
 
@@ -6691,6 +9360,73 @@ abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
     return handleUnresolvedSuperSetterIndexPostfixPrefix(
         node, indexFunction, element, index, operator, arg, isPrefix: true);
   }
+
+  @override
+  R visitSuperFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitSuperFinalFieldPostfix
+  }
+
+  @override
+  R visitSuperMethodPostfix(
+      Send node,
+      FunctionElement method,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitSuperMethodPostfix
+  }
+
+  @override
+  R visitUnresolvedSuperPostfix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitUnresolvedSuperPostfix
+  }
+
+  @override
+  R visitUnresolvedSuperGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitUnresolvedSuperGetterPostfix
+  }
+
+  @override
+  R visitUnresolvedSuperGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitUnresolvedSuperGetterPrefix
+  }
+
+  @override
+  R visitUnresolvedSuperSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitUnresolvedSuperSetterPostfix
+  }
+
+  @override
+  R visitUnresolvedSuperSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      A arg) {
+    // TODO: implement visitUnresolvedSuperSetterPrefix
+  }
 }
 
 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
@@ -6720,6 +9456,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, constructor, type, arguments, callStructure, arg);
   }
 
+  @override
   R visitRedirectingGenerativeConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
@@ -6731,6 +9468,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, constructor, type, arguments, callStructure, arg);
   }
 
+  @override
   R visitFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
@@ -6742,6 +9480,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, constructor, type, arguments, callStructure, arg);
   }
 
+  @override
   R visitRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
@@ -6755,6 +9494,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, constructor, type, arguments, callStructure, arg);
   }
 
+  @override
   R visitUnresolvedConstructorInvoke(
       NewExpression node,
       Element constructor,
@@ -6766,6 +9506,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, constructor, type, arguments, selector.callStructure, arg);
   }
 
+  @override
   R visitUnresolvedClassConstructorInvoke(
       NewExpression node,
       Element element,
@@ -6777,6 +9518,7 @@ abstract class BaseImplementationOfNewMixin<R, A>
         node, element, type, arguments, selector.callStructure, arg);
   }
 
+  @override
   R visitAbstractClassConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,
@@ -6787,6 +9529,8 @@ abstract class BaseImplementationOfNewMixin<R, A>
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
+
+  @override
   R visitUnresolvedRedirectingFactoryConstructorInvoke(
       NewExpression node,
       ConstructorElement constructor,