Implement ResolvedVisitor using SemanticSendVisitor.

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js.semantics_visitor;
 
 /// Mixin that implements all `errorX` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `errorX` methods.
 abstract class ErrorBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleError(Send node) {
-    return bulkHandleNode(node, "Error expression `$node` unhandled.");
+  R bulkHandleError(Send node, A arg) {
+    return bulkHandleNode(node, "Error expression `$node` unhandled.", arg);
   }
 
   @override
   R errorInvalidAssert(
       Send node,
       NodeList arguments,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorClassTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorClassTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorClassTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorClassTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorDynamicTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorDynamicTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorDynamicTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorDynamicTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalLocalVariableCompound(
       Send node,
       LocalVariableElement
       variable,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalLocalVariableSet(
       SendSet node,
       LocalVariableElement variable,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalParameterSet(
       SendSet node,
       ParameterElement parameter,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalStaticFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalStaticFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalSuperFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalSuperFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalTopLevelFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorFinalTopLevelFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorLocalFunctionCompound(
       Send node,
       LocalFunctionElement function,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorLocalFunctionSet(
       SendSet node,
       LocalFunctionElement function,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorStaticFunctionSet(
       Send node,
       MethodElement function,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorStaticGetterSet(
       SendSet node,
       FunctionElement getter,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorStaticSetterGet(
       Send node,
       FunctionElement setter,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorStaticSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorSuperGetterSet(
       SendSet node,
       FunctionElement getter,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorSuperMethodSet(
       Send node,
       MethodElement method,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorSuperSetterGet(
       Send node,
       FunctionElement setter,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorSuperSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTopLevelFunctionSet(
       Send node,
       MethodElement function,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTopLevelGetterSet(
       SendSet node,
       FunctionElement getter,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTopLevelSetterGet(
       Send node,
       FunctionElement setter,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTopLevelSetterInvoke(
       Send node,
       FunctionElement setter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypeVariableTypeLiteralSet(
       SendSet node,
       TypeVariableElement element,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypedefTypeLiteralCompound(
       Send node,
       TypeConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypedefTypeLiteralPostfix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypedefTypeLiteralPrefix(
       Send node,
       TypeConstantExpression constant,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorTypedefTypeLiteralSet(
       SendSet node,
       TypeConstantExpression constant,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedCompound(
       Send node,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedGet(
       Send node,
       Element element,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedPostfix(
       Send node,
       Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedPrefix(
       Send node,
       Element element,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSet(
       Send node,
       Element element,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperCompoundIndexSet(
       SendSet node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperIndex(
       Send node,
       Element function,
       Node index,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperIndexPostfix(
       Send node,
       Element function,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperIndexPrefix(
       Send node,
       Element function,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperIndexSet(
       SendSet node,
       Element element,
       Node index,
       Node rhs,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperBinary(
       Send node,
       Element element,
       BinaryOperator operator,
       Node argument,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUnresolvedSuperUnary(
       Send node,
       UnaryOperator operator,
       Element element,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUndefinedBinaryExpression(
       Send node,
       Node left,
       Operator operator,
       Node right,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 
   @override
   R errorUndefinedUnaryExpression(
       Send node,
       Operator operator,
       Node expression,
       A arg) {
-    return bulkHandleError(node);
+    return bulkHandleError(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXPrefix` methods of [SemanticSendVisitor] by
 /// delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `visitXPrefix`
 /// methods.
 abstract class PrefixBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandlePrefix(Send node) {
-    return bulkHandleNode(node, "Prefix expression `$node` unhandled.");
+  R bulkHandlePrefix(Send node, A arg) {
+    return bulkHandleNode(node, "Prefix expression `$node` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitIndexPrefix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitLocalVariablePrefix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitParameterPrefix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitStaticFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitStaticGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitStaticMethodSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperFieldFieldPrefix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperFieldSetterPrefix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperGetterFieldPrefix(
       Send node,
       FunctionElement getter,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperIndexPrefix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitThisPropertyPrefix(
       Send node,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePrefix(node);
+    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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandlePostfix(Send node) {
-    return bulkHandleNode(node, "Postfix expression `$node` unhandled.");
+  R bulkHandlePostfix(Send node, A arg) {
+    return bulkHandleNode(node, "Postfix expression `$node` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitParameterPostfix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitStaticFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitStaticGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitStaticMethodSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperFieldFieldPostfix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperFieldSetterPostfix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperGetterFieldPostfix(
       Send node,
       FunctionElement getter,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperIndexPostfix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitThisPropertyPostfix(
       Send node,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandlePostfix(node);
+    return bulkHandlePostfix(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXCompound` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `xCompound`
 /// methods.
 abstract class CompoundBulkMixin<R, A> implements SemanticSendVisitor<R, A> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleCompound(Send node) {
-    return bulkHandleNode(node, "Compound assignment `$node` unhandled.");
+  R bulkHandleCompound(Send node, A arg) {
+    return bulkHandleNode(node, "Compound assignment `$node` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitStaticFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitStaticGetterSetterCompound(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitStaticMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperFieldSetterCompound(
       Send node,
       FieldElement field,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperGetterFieldCompound(
       Send node,
       FunctionElement getter,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperGetterSetterCompound(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitThisPropertyCompound(
       Send node,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitTopLevelFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitTopLevelGetterSetterCompound(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleCompound(node);
+    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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleInvoke(Send node) {
-    return bulkHandleNode(node, "Invocation `$node` unhandled.");
+  R bulkHandleInvoke(Send node, A arg) {
+    return bulkHandleNode(node, "Invocation `$node` unhandled.", arg);
   }
 
   @override
   R visitClassTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitDynamicTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitExpressionInvoke(
       Send node,
       Node expression,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitLocalFunctionInvoke(
       Send node,
       LocalFunctionElement function,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitLocalVariableInvoke(
       Send node,
       LocalVariableElement variable,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitParameterInvoke(
       Send node,
       ParameterElement parameter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitStaticFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitStaticFunctionInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitStaticGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitSuperFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitSuperGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitSuperMethodInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitThisInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitTopLevelFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitTopLevelFunctionInvoke(
       Send node,
       MethodElement function,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitTopLevelGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitTypeVariableTypeLiteralInvoke(
       Send node,
       TypeVariableElement element,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitTypedefTypeLiteralInvoke(
       Send node,
       TypeConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitConstantInvoke(
       Send node,
       ConstantExpression constant,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleInvoke(node);
+    return bulkHandleInvoke(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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleGet(Node node) {
-    return bulkHandleNode(node, "Read `$node` unhandled.");
+  R bulkHandleGet(Node node, A arg) {
+    return bulkHandleNode(node, "Read `$node` unhandled.", arg);
   }
 
   @override
   R visitClassTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitDynamicPropertyGet(
       Send node,
       Node receiver,
       Selector selector,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitDynamicTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitLocalFunctionGet(
       Send node,
       LocalFunctionElement function,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitLocalVariableGet(
       Send node,
       LocalVariableElement variable,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitParameterGet(
       Send node,
       ParameterElement parameter,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitStaticFieldGet(
       Send node,
       FieldElement field,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitStaticFunctionGet(
       Send node,
       MethodElement function,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitStaticGetterGet(
       Send node,
       FunctionElement getter,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitSuperFieldGet(
       Send node,
       FieldElement field,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitSuperGetterGet(
       Send node,
       FunctionElement getter,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitSuperMethodGet(
       Send node,
       MethodElement method,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitThisGet(Identifier node, A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitThisPropertyGet(
       Send node,
       Selector selector,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTopLevelFieldGet(
       Send node,
       FieldElement field,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTopLevelFunctionGet(
       Send node,
       MethodElement function,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTopLevelGetterGet(
       Send node,
       FunctionElement getter,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTypeVariableTypeLiteralGet(
       Send node,
       TypeVariableElement element,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTypedefTypeLiteralGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
-    return bulkHandleGet(node);
+    return bulkHandleGet(node, arg);
   }
 
   @override
   R visitConstantGet(
       Send node,
       TypeConstantExpression constant,
       A arg) {
-    return bulkHandleGet(node);
+    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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleSet(Send node) {
-    return bulkHandleNode(node, "Assignment `$node` unhandled.");
+  R bulkHandleSet(Send node, A arg) {
+    return bulkHandleNode(node, "Assignment `$node` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node,
       Node receiver,
       Selector selector,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitLocalVariableSet(
       SendSet node,
       LocalVariableElement variable,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitParameterSet(
       SendSet node,
       ParameterElement parameter,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitStaticFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitStaticSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitSuperFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitSuperSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitThisPropertySet(
       SendSet node,
       Selector selector,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTopLevelFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTopLevelSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
-    return bulkHandleSet(node);
+    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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleIndexSet(Send node) {
-    return bulkHandleNode(node, "Index set expression `$node` unhandled.");
+  R bulkHandleIndexSet(Send node, A arg) {
+    return bulkHandleNode(node, "Index set expression `$node` unhandled.", arg);
   }
 
   @override
   R visitCompoundIndexSet(
       SendSet node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node);
+    return bulkHandleIndexSet(node, arg);
   }
 
   @override
   R visitIndexSet(
       SendSet node,
       Node receiver,
       Node index,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node);
+    return bulkHandleIndexSet(node, arg);
   }
 
   @override
   R visitSuperCompoundIndexSet(
       SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node);
+    return bulkHandleIndexSet(node, arg);
   }
 
   @override
   R visitSuperIndexSet(
       SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg) {
-    return bulkHandleIndexSet(node);
+    return bulkHandleIndexSet(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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleBinary(Send node) {
-    return bulkHandleNode(node, "Binary expression `$node` unhandled.");
+  R bulkHandleBinary(Send node, A arg) {
+    return bulkHandleNode(node, "Binary expression `$node` unhandled.", arg);
   }
 
   @override
   R visitBinary(
       Send node,
       Node left,
       BinaryOperator operator,
       Node right,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitEquals(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitNotEquals(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitIndex(
       Send node,
       Node receiver,
       Node index,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitSuperBinary(
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitSuperEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitSuperNotEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
-    return bulkHandleBinary(node);
+    return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitSuperIndex(
       Send node,
       FunctionElement function,
       Node index,
       A arg) {
-    return bulkHandleBinary(node);
+    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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleUnary(Send node) {
-    return bulkHandleNode(node, "Unary expression `$node` unhandled.");
+  R bulkHandleUnary(Send node, A arg) {
+    return bulkHandleNode(node, "Unary expression `$node` unhandled.", arg);
   }
 
   @override
   R visitNot(
       Send node,
       Node expression,
       A arg) {
-    return bulkHandleUnary(node);
+    return bulkHandleUnary(node, arg);
   }
 
   @override
   R visitSuperUnary(Send node, UnaryOperator operator,
                     FunctionElement function, A arg) {
-    return bulkHandleUnary(node);
+    return bulkHandleUnary(node, arg);
   }
 
   @override
   R visitUnary(
       Send node,
       UnaryOperator operator,
       Node expression,
       A arg) {
-    return bulkHandleUnary(node);
+    return bulkHandleUnary(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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
   @override
   R visitAs(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'As cast `$node` unhandled.');
+    return bulkHandleNode(node, 'As cast `$node` unhandled.', arg);
   }
 
   @override
   R visitAssert(
       Send node,
       Node expression,
       A arg) {
-    return bulkHandleNode(node, 'Assert `$node` unhandled.');
+    return bulkHandleNode(node, 'Assert `$node` unhandled.', arg);
   }
 
   @override
   R visitIs(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'Is test `$node` unhandled.');
+    return bulkHandleNode(node, 'Is test `$node` unhandled.', arg);
   }
 
   @override
   R visitIsNot(
       Send node,
       Node expression,
       DartType type,
       A arg) {
-    return bulkHandleNode(node, 'Is not test `$node` unhandled.');
+    return bulkHandleNode(node, 'Is not test `$node` unhandled.', arg);
   }
 
   @override
   R visitLogicalAnd(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleNode(node, 'Lazy and `$node` unhandled.');
+    return bulkHandleNode(node, 'Lazy and `$node` unhandled.', arg);
   }
 
   @override
   R visitLogicalOr(
       Send node,
       Node left,
       Node right,
       A arg) {
-    return bulkHandleNode(node, 'Lazy or `$node` unhandled.');
+    return bulkHandleNode(node, 'Lazy or `$node` 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> {
-  R bulkHandleNode(Node node, String message);
+  R bulkHandleNode(Node node, String message, A arg);
 
-  R bulkHandleSuper(Send node) {
-    return bulkHandleNode(node, "Super call `$node` unhandled.");
+  R bulkHandleSuper(Send node, A arg) {
+    return bulkHandleNode(node, "Super call `$node` unhandled.", arg);
   }
 
   @override
   R visitSuperBinary(
       Send node,
       FunctionElement function,
       BinaryOperator operator,
       Node argument,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperCompoundIndexSet(
       SendSet node,
       FunctionElement getter,
       FunctionElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldFieldPostfix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldFieldPrefix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldGet(
       Send node,
       FieldElement field,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldInvoke(
       Send node,
       FieldElement field,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldSetterCompound(
       Send node,
       FieldElement field,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldSetterPostfix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldSetterPrefix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterFieldCompound(
       Send node,
       FunctionElement getter,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterFieldPostfix(
       Send node,
       FunctionElement getter,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterFieldPrefix(
       Send node,
       FunctionElement getter,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterGet(
       Send node,
       FunctionElement getter,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterInvoke(
       Send node,
       FunctionElement getter,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterSetterCompound(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperGetterSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperIndexSet(
       SendSet node,
       FunctionElement function,
       Node index,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperMethodGet(
       Send node,
       MethodElement method,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperMethodInvoke(
       Send node,
       MethodElement method,
       NodeList arguments,
       Selector selector,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperNotEquals(
       Send node,
       FunctionElement function,
       Node argument,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperSetterSet(
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperUnary(
       Send node,
       UnaryOperator operator,
       FunctionElement function,
       A arg) {
-    return bulkHandleSuper(node);
+    return bulkHandleSuper(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 BulkVisitor<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> {
-
   @override
   R apply(Node node, A arg) {
     throw new UnimplementedError("BulkVisitor.apply unimplemented");
   }
 
   @override
-  R bulkHandleNode(Node node, String message) {
+  R bulkHandleNode(Node node, String message, A arg) {
     throw new UnimplementedError("BulkVisitor.bulkHandleNode unimplemented");
   }
 }
 
 /// [SemanticSendVisitor] that visits subnodes.
 class TraversalMixin<R, A> implements SemanticSendVisitor<R, A> {
   @override
   R apply(Node node, A arg) {
     throw new UnimplementedError("TraversalMixin.apply unimplemented");
   }
@@ skipping 1768 matching lines @@
     return null;
   }
 
   @override
   R errorUnresolvedSuperIndexPostfix(
       Send node,
       Element function,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement errorUnresolvedSuperIndexPostfix
+    apply(index, arg);
+    return null;
   }
 
   @override
   R errorUnresolvedSuperIndexPrefix(
       Send node,
       Element function,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement errorUnresolvedSuperIndexPrefix
+    apply(index, arg);
+    return null;
   }
 
   @override
   R visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement visitIndexPostfix
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
   }
 
   @override
   R visitIndexPrefix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement visitIndexPrefix
+    apply(receiver, arg);
+    apply(index, arg);
+    return null;
   }
 
   @override
   R visitSuperIndexPostfix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement visitSuperIndexPostfix
+    apply(index, arg);
+    return null;
   }
 
   @override
   R visitSuperIndexPrefix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
-    // TODO: implement visitSuperIndexPrefix
+    apply(index, 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 TraversalMixin<R, A> {
   TraversalVisitor(TreeElements elements) : super(elements);
 
   SemanticSendVisitor<R, A> get sendVisitor => this;
@@ skipping 1161 matching lines @@
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexPostfixPrefix(
         node, indexFunction, indexSetFunction,
         index, operator, arg, isPrefix: true);
   }
 }