// 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;

/// Interface for bulk handling of a [Node] in a semantic visitor.
abstract class BulkHandle<R, A> {
  /// Handle [node] either regardless of semantics or to report that [node] is
  /// unhandled. [message] contains a message template for the latter case:
  /// Replace '#' in [message] by `node.toString()` to create a message for the
  /// error.
  R bulkHandleNode(Node node, String message, A arg);
}

/// 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>, BulkHandle<R, A> {

  R bulkHandleError(Node node, A arg) {
    return bulkHandleNode(node, "Error expression `#` unhandled.", arg);
  }

  @override
  R errorInvalidAssert(
      Send node,
      NodeList arguments,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalLocalVariableCompound(
      Send node,
      LocalVariableElement
      variable,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalLocalVariableSet(
      SendSet node,
      LocalVariableElement variable,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalParameterCompound(
      Send node,
      ParameterElement parameter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalParameterSet(
      SendSet node,
      ParameterElement parameter,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalStaticFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalStaticFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalSuperFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalSuperFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalTopLevelFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorFinalTopLevelFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorNonConstantConstructorInvoke(
      NewExpression node,
      Element element,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorStaticFunctionSet(
      Send node,
      MethodElement function,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorStaticGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorStaticSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorStaticSetterInvoke(
      Send node,
      FunctionElement setter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorSuperGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorSuperMethodSet(
      Send node,
      MethodElement method,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorSuperSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorSuperSetterInvoke(
      Send node,
      FunctionElement setter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorTopLevelFunctionSet(
      Send node,
      MethodElement function,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorTopLevelGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorTopLevelSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorTopLevelSetterInvoke(
      Send node,
      FunctionElement setter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @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,
      Node rhs,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorUndefinedUnaryExpression(
      Send node,
      Operator operator,
      Node expression,
      A arg) {
    return bulkHandleError(node, arg);
  }

  @override
  R errorUndefinedBinaryExpression(
      Send node,
      Node left,
      Operator operator,
      Node right,
      A arg) {
    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>, BulkHandle<R, A> {

  R bulkHandlePrefix(Send node, A arg) {
    return bulkHandleNode(node, "Prefix expression `#` unhandled.", arg);
  }

  @override
  R visitDynamicPropertyPrefix(
      Send node,
      Node receiver,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitIndexPrefix(
      Send node,
      Node receiver,
      Node index,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitLocalVariablePrefix(
      Send node,
      LocalVariableElement variable,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitParameterPrefix(
      Send node,
      ParameterElement parameter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitStaticFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitStaticGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitStaticMethodSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperFieldFieldPrefix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperFieldSetterPrefix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperGetterFieldPrefix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperIndexPrefix(
      Send node,
      FunctionElement indexFunction,
      FunctionElement indexSetFunction,
      Node index,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitUnresolvedSuperGetterIndexPrefix(
      Send node,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitUnresolvedSuperSetterIndexPrefix(
      Send node,
      MethodElement getter,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitSuperMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitThisPropertyPrefix(
      Send node,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitTopLevelFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitTopLevelGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePrefix(node, arg);
  }

  @override
  R visitTopLevelMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      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(
      Send node,
      Node receiver,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitIndexPostfix(
      Send node,
      Node receiver,
      Node index,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitLocalVariablePostfix(
      Send node,
      LocalVariableElement variable,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitParameterPostfix(
      Send node,
      ParameterElement parameter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitStaticFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitStaticGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitStaticMethodSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitSuperFieldFieldPostfix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitSuperFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitSuperFieldSetterPostfix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitSuperGetterFieldPostfix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitSuperGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  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,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitThisPropertyPostfix(
      Send node,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitTopLevelFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitTopLevelGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandlePostfix(node, arg);
  }

  @override
  R visitTopLevelMethodSetterPostfix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    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>, BulkHandle<R, A> {

  R bulkHandleCompound(Send node, A arg) {
    return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
  }

  @override
  R visitDynamicPropertyCompound(
      Send node,
      Node receiver,
      AssignmentOperator operator,
      Node rhs,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitLocalVariableCompound(
      Send node,
      LocalVariableElement variable,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitParameterCompound(
      Send node,
      ParameterElement parameter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitStaticFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitStaticGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitStaticMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitSuperFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitSuperFieldSetterCompound(
      Send node,
      FieldElement field,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitSuperGetterFieldCompound(
      Send node,
      FunctionElement getter,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitSuperGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitSuperMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitThisPropertyCompound(
      Send node,
      AssignmentOperator operator,
      Node rhs,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitTopLevelFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitTopLevelGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleCompound(node, arg);
  }

  @override
  R visitTopLevelMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      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);
  }

  @override
  R visitClassTypeLiteralInvoke(
      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,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitDynamicTypeLiteralInvoke(
      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,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitLocalFunctionInvoke(
      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,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitStaticFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitStaticFunctionInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitStaticFunctionIncompatibleInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitStaticGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitSuperFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitSuperGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitSuperMethodInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitSuperMethodIncompatibleInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitThisInvoke(
      Send node,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitThisPropertyInvoke(
      Send node,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTopLevelFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTopLevelFunctionInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTopLevelFunctionIncompatibleInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTopLevelGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTypeVariableTypeLiteralInvoke(
      Send node,
      TypeVariableElement element,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitTypedefTypeLiteralInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitConstantInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitUnresolvedInvoke(
      Send node,
      Element element,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInvoke(node, arg);
  }

  @override
  R visitUnresolvedSuperInvoke(
      Send node,
      Element function,
      NodeList arguments,
      Selector selector,
      A arg) {
    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>, BulkHandle<R, A> {

  R bulkHandleGet(Node node, A arg) {
    return bulkHandleNode(node, "Read `#` unhandled.", arg);
  }

  @override
  R visitClassTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitDynamicPropertyGet(
      Send node,
      Node receiver,
      Selector selector,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitDynamicTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitLocalFunctionGet(
      Send node,
      LocalFunctionElement function,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitLocalVariableGet(
      Send node,
      LocalVariableElement variable,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitParameterGet(
      Send node,
      ParameterElement parameter,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitStaticFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitStaticFunctionGet(
      Send node,
      MethodElement function,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitStaticGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitSuperFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitSuperGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitSuperMethodGet(
      Send node,
      MethodElement method,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitThisGet(Identifier node, A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitThisPropertyGet(
      Send node,
      Selector selector,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitTopLevelFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitTopLevelFunctionGet(
      Send node,
      MethodElement function,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitTopLevelGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitTypeVariableTypeLiteralGet(
      Send node,
      TypeVariableElement element,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitTypedefTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitConstantGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitUnresolvedGet(
      Send node,
      Element element,
      A arg) {
    return bulkHandleGet(node, arg);
  }

  @override
  R visitUnresolvedSuperGet(
      Send node,
      Element element,
      A 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 visitDynamicPropertySet(
      SendSet node,
      Node receiver,
      Selector selector,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitLocalVariableSet(
      SendSet node,
      LocalVariableElement variable,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitParameterSet(
      SendSet node,
      ParameterElement parameter,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitStaticFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitStaticSetterSet(
      SendSet node,
      FunctionElement setter,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitSuperFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  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 bulkHandleSet(node, arg);
  }

  @override
  R visitTopLevelFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleSet(node, arg);
  }

  @override
  R visitTopLevelSetterSet(
      SendSet node,
      FunctionElement setter,
      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);
  }

  @override
  R visitSuperCompoundIndexSet(
      SendSet node,
      FunctionElement getter,
      FunctionElement setter,
      Node index,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleIndexSet(node, arg);
  }

  @override
  R visitUnresolvedSuperGetterCompoundIndexSet(
      SendSet node,
      Element element,
      Node index,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleIndexSet(node, arg);
  }

  @override
  R visitUnresolvedSuperSetterCompoundIndexSet(
      SendSet node,
      MethodElement getter,
      Element element,
      Node index,
      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);
  }

  @override
  R visitUnresolvedSuperIndexSet(
      SendSet node,
      Element element,
      Node index,
      Node rhs,
      A arg) {
    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>, BulkHandle<R, A> {

  R bulkHandleBinary(Send node, A arg) {
    return bulkHandleNode(node, "Binary expression `#` unhandled.", arg);
  }

  @override
  R visitBinary(
      Send node,
      Node left,
      BinaryOperator operator,
      Node right,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitEquals(
      Send node,
      Node left,
      Node right,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitNotEquals(
      Send node,
      Node left,
      Node right,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitIndex(
      Send node,
      Node receiver,
      Node index,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitSuperBinary(
      Send node,
      FunctionElement function,
      BinaryOperator operator,
      Node argument,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitSuperEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitSuperNotEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitSuperIndex(
      Send node,
      FunctionElement function,
      Node index,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitUnresolvedSuperBinary(
      Send node,
      FunctionElement function,
      BinaryOperator operator,
      Node argument,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitUnresolvedSuperInvoke(
      Send node,
      Element function,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleBinary(node, arg);
  }

  @override
  R visitUnresolvedSuperIndex(
      Send node,
      FunctionElement function,
      Node index,
      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);
  }

  @override
  R visitNot(
      Send node,
      Node expression,
      A arg) {
    return bulkHandleUnary(node, arg);
  }

  @override
  R visitSuperUnary(
      Send node,
      UnaryOperator operator,
      FunctionElement function,
      A arg) {
    return bulkHandleUnary(node, arg);
  }

  @override
  R visitUnary(
      Send node,
      UnaryOperator operator,
      Node expression,
      A arg) {
    return bulkHandleUnary(node, arg);
  }

  @override
  R visitUnresolvedSuperUnary(
      Send node,
      UnaryOperator operator,
      FunctionElement function,
      A arg) {
    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>, BulkHandle<R, A> {

  @override
  R visitAs(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    return bulkHandleNode(node, 'As cast `#` unhandled.', arg);
  }

  @override
  R visitAssert(
      Send node,
      Node expression,
      A arg) {
    return bulkHandleNode(node, 'Assert `#` unhandled.', arg);
  }

  @override
  R visitIs(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    return bulkHandleNode(node, 'Is test `#` unhandled.', arg);
  }

  @override
  R visitIsNot(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    return bulkHandleNode(node, 'Is not test `#` unhandled.', arg);
  }

  @override
  R visitLogicalAnd(
      Send node,
      Node left,
      Node right,
      A arg) {
    return bulkHandleNode(node, 'Lazy and `#` unhandled.', arg);
  }

  @override
  R visitLogicalOr(
      Send node,
      Node left,
      Node right,
      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);
  }

  @override
  R visitSuperBinary(
      Send node,
      FunctionElement function,
      BinaryOperator operator,
      Node argument,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperCompoundIndexSet(
      SendSet node,
      FunctionElement getter,
      FunctionElement setter,
      Node index,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldFieldPostfix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldFieldPrefix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldSetterCompound(
      Send node,
      FieldElement field,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldSetterPostfix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperFieldSetterPrefix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterFieldCompound(
      Send node,
      FunctionElement getter,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterFieldPostfix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterFieldPrefix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperIndexSet(
      SendSet node,
      FunctionElement function,
      Node index,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodGet(
      Send node,
      MethodElement method,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodIncompatibleInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodSetterPostfix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperNotEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperSetterSet(
      SendSet node,
      FunctionElement setter,
      Node rhs,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitSuperUnary(
      Send node,
      UnaryOperator operator,
      FunctionElement function,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitUnresolvedSuperBinary(
      Send node,
      Element element,
      BinaryOperator operator,
      Node argument,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitUnresolvedSuperGet(
      Send node,
      Element element,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitUnresolvedSuperInvoke(
      Send node,
      Element function,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitUnresolvedSuperIndex(
      Send node,
      Element function,
      Node index,
      A arg) {
    return bulkHandleSuper(node, arg);
  }

  @override
  R visitUnresolvedSuperUnary(
      Send node,
      UnaryOperator operator,
      Element element,
      A arg) {
    return bulkHandleSuper(node, arg);
  }
}

abstract class NewBulkMixin<R, A>
    implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {

  R bulkHandleNew(NewExpression node, A arg) {
    return bulkHandleNode(
        node, "Constructor invocation `#` unhandled.", arg);
  }

  @override
  R visitAbstractClassConstructorInvoke(
      NewExpression node,
      ConstructorElement element,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  @override
  R visitConstConstructorInvoke(
      NewExpression node,
      ConstructedConstantExpression constant,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  R visitGenerativeConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  R visitRedirectingGenerativeConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  R visitFactoryConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  R visitRedirectingFactoryConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      ConstructorElement effectiveTarget,
      InterfaceType effectiveTargetType,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  @override
  R visitUnresolvedClassConstructorInvoke(
      NewExpression node,
      Element element,
      DartType type,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  @override
  R visitUnresolvedConstructorInvoke(
      NewExpression node,
      Element constructor,
      DartType type,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleNew(node, arg);
  }

  @override
  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 apply(Node node, A arg) {
    throw new UnimplementedError("BulkSendVisitor.apply unimplemented");
  }

  @override
  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 visitInitializingFormalDeclaration(
      VariableDefinitions node,
      Node definition,
      InitializingFormalElement parameter,
      int index,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }

  @override
  R visitNamedInitializingFormalDeclaration(
      VariableDefinitions node,
      Node definition,
      InitializingFormalElement parameter,
      ConstantExpression defaultValue,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }

  @override
  R visitNamedParameterDeclaration(
      VariableDefinitions node,
      Node definition,
      ParameterElement parameter,
      ConstantExpression defaultValue,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }

  @override
  R visitOptionalInitializingFormalDeclaration(
      VariableDefinitions node,
      Node definition,
      InitializingFormalElement parameter,
      ConstantExpression defaultValue,
      int index,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }

  @override
  R visitOptionalParameterDeclaration(
      VariableDefinitions node,
      Node definition,
      ParameterElement parameter,
      ConstantExpression defaultValue,
      int index,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }

  @override
  R visitParameterDeclaration(
      VariableDefinitions node,
      Node definition,
      ParameterElement parameter,
      int index,
      A arg) {
    return bulkHandleParameterDeclaration(node, arg);
  }
}

/// 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 visitFactoryConstructorDeclaration(
      FunctionExpression node,
      ConstructorElement constructor,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleConstructorDeclaration(node, arg);
  }

  @override
  R visitGenerativeConstructorDeclaration(
      FunctionExpression node,
      ConstructorElement constructor,
      NodeList parameters,
      NodeList initializers,
      Node body,
      A arg) {
    return bulkHandleConstructorDeclaration(node, arg);
  }

  @override
  R visitRedirectingFactoryConstructorDeclaration(
      FunctionExpression node,
      ConstructorElement constructor,
      NodeList parameters,
      InterfaceType redirectionType,
      ConstructorElement redirectionTarget,
      A arg) {
    return bulkHandleConstructorDeclaration(node, arg);
  }

  @override
  R visitRedirectingGenerativeConstructorDeclaration(
      FunctionExpression node,
      ConstructorElement constructor,
      NodeList parameters,
      NodeList initializers,
      A arg) {
    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 errorUnresolvedFieldInitializer(
      SendSet node,
      Element element,
      Node initializer,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }

  @override
  R errorUnresolvedSuperConstructorInvoke(
      Send node,
      Element element,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }

  @override
  R errorUnresolvedThisConstructorInvoke(
      Send node,
      Element element,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }

  @override
  R visitFieldInitializer(
      SendSet node,
      FieldElement field,
      Node initializer,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }

  @override
  R visitSuperConstructorInvoke(
      Send node,
      ConstructorElement superConstructor,
      InterfaceType type,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }

  @override
  R visitThisConstructorInvoke(
      Send node,
      ConstructorElement thisConstructor,
      NodeList arguments,
      Selector selector,
      A arg) {
    return bulkHandleInitializer(node, arg);
  }
}

/// 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 visitAbstractGetterDeclaration(
      FunctionExpression node,
      MethodElement getter,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitAbstractMethodDeclaration(
      FunctionExpression node,
      MethodElement method,
      NodeList parameters,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitAbstractSetterDeclaration(
      FunctionExpression node,
      MethodElement setter,
      NodeList parameters,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitClosureDeclaration(
      FunctionExpression node,
      LocalFunctionElement closure,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitInstanceGetterDeclaration(
      FunctionExpression node,
      MethodElement getter,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitInstanceMethodDeclaration(
      FunctionExpression node,
      MethodElement method,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitInstanceSetterDeclaration(
      FunctionExpression node,
      MethodElement setter,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitLocalFunctionDeclaration(
      FunctionExpression node,
      LocalFunctionElement function,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitStaticFunctionDeclaration(
      FunctionExpression node,
      MethodElement function,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitStaticGetterDeclaration(
      FunctionExpression node,
      MethodElement getter,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitStaticSetterDeclaration(
      FunctionExpression node,
      MethodElement setter,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitTopLevelFunctionDeclaration(
      FunctionExpression node,
      MethodElement function,
      NodeList parameters,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitTopLevelGetterDeclaration(
      FunctionExpression node,
      MethodElement getter,
      Node body,
      A arg) {
    return bulkHandleFunctionDeclaration(node, arg);
  }

  @override
  R visitTopLevelSetterDeclaration(
      FunctionExpression node,
      MethodElement setter,
      NodeList parameters,
      Node body,
      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);
  }

  @override
  R visitInstanceFieldDeclaration(
      VariableDefinitions node,
      Node definition,
      FieldElement field,
      Node initializer,
      A arg) {
    return bulkHandleVariableDeclaration(node, arg);
  }

  @override
  R visitLocalConstantDeclaration(
      VariableDefinitions node,
      Node definition,
      LocalVariableElement variable,
      ConstantExpression constant,
      A arg) {
    return bulkHandleVariableDeclaration(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,
      FieldElement field,
      ConstantExpression constant,
      A arg) {
    return bulkHandleVariableDeclaration(node, arg);
  }

  @override
  R visitStaticFieldDeclaration(
      VariableDefinitions node,
      Node definition,
      FieldElement field,
      Node initializer,
      A arg) {
    return bulkHandleVariableDeclaration(node, arg);
  }

  @override
  R visitTopLevelConstantDeclaration(
      VariableDefinitions node,
      Node definition,
      FieldElement field,
      ConstantExpression constant,
      A arg) {
    return bulkHandleVariableDeclaration(node, arg);
  }

  @override
  R visitTopLevelFieldDeclaration(
      VariableDefinitions node,
      Node definition,
      FieldElement field,
      Node initializer,
      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");
  }

  @override
  R errorInvalidAssert(
      Send node,
      NodeList arguments,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorClassTypeLiteralSet(
      SendSet node,
      ConstantExpression constant,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorDynamicTypeLiteralSet(
      SendSet node,
      ConstantExpression constant,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalLocalVariableCompound(
      Send node,
      LocalVariableElement variable,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalLocalVariableSet(
      SendSet node,
      LocalVariableElement variable,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalParameterCompound(
      Send node,
      ParameterElement parameter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalParameterSet(
      SendSet node,
      ParameterElement parameter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalStaticFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalStaticFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalSuperFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalSuperFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalTopLevelFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorFinalTopLevelFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorLocalFunctionCompound(
      Send node,
      LocalFunctionElement function,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorLocalFunctionPostfix(
      Send node,
      LocalFunctionElement function,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorLocalFunctionPrefix(
      Send node,
      LocalFunctionElement function,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorLocalFunctionSet(
      SendSet node,
      LocalFunctionElement function,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorStaticFunctionSet(
      Send node,
      MethodElement function,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorStaticGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorStaticSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return null;
  }

  @override
  R errorStaticSetterInvoke(
      Send node,
      FunctionElement setter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorSuperGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorSuperMethodSet(
      Send node,
      MethodElement method,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorSuperSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return null;
  }

  @override
  R errorSuperSetterInvoke(
      Send node,
      FunctionElement setter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorTopLevelFunctionSet(
      Send node,
      MethodElement function,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorTopLevelGetterSet(
      SendSet node,
      FunctionElement getter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorTopLevelSetterGet(
      Send node,
      FunctionElement setter,
      A arg) {
    return null;
  }

  @override
  R errorTopLevelSetterInvoke(
      Send node,
      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);
    return null;
  }

  @override
  R errorTypedefTypeLiteralSet(
      SendSet node,
      ConstantExpression constant,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitUnresolvedSuperIndex(
      Send node,
      Element function,
      Node index,
      A arg) {
    apply(index, arg);
    return null;
  }

  @override
  R visitUnresolvedSuperGet(
      Send node,
      Element element,
      A arg) {
    return null;
  }

  @override
  R visitUnresolvedSuperInvoke(
      Send node,
      Element function,
      NodeList arguments,
      Selector selector,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitAs(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R visitAssert(
      Send node,
      Node expression,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R visitBinary(
      Send node,
      Node left,
      BinaryOperator operator,
      Node right,
      A arg) {
    apply(left, arg);
    apply(right, arg);
    return null;
  }

  @override
  R errorClassTypeLiteralCompound(
      Send node,
      ConstantExpression constant,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitClassTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return null;
  }

  @override
  R visitClassTypeLiteralInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorClassTypeLiteralPostfix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorClassTypeLiteralPrefix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  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 visitConstantGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return null;
  }

  @override
  R visitConstantInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitDynamicPropertyCompound(
      Send node,
      Node receiver,
      AssignmentOperator operator,
      Node rhs,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    apply(receiver, arg);
    apply(rhs, arg);
    return null;
  }

  @override
  R visitDynamicPropertyGet(
      Send node,
      Node receiver,
      Selector selector,
      A arg) {
    apply(receiver, arg);
    return null;
  }

  @override
  R visitDynamicPropertyInvoke(
      Send node,
      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 visitDynamicPropertyPrefix(
      Send node,
      Node receiver,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    apply(receiver, arg);
    return null;
  }

  @override
  R visitDynamicPropertySet(
      SendSet node,
      Node receiver,
      Selector selector,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorDynamicTypeLiteralCompound(
      Send node,
      ConstantExpression constant,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitDynamicTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return null;
  }

  @override
  R visitDynamicTypeLiteralInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorDynamicTypeLiteralPostfix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorDynamicTypeLiteralPrefix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitEquals(
      Send node,
      Node left,
      Node right,
      A arg) {
    apply(left, arg);
    apply(right, arg);
    return null;
  }

  @override
  R visitExpressionInvoke(
      Send node,
      Node expression,
      NodeList arguments,
      Selector selector,
      A arg) {
    apply(expression, arg);
    apply(arguments, arg);
    return null;
  }

  @override
  R visitIndex(
      Send node,
      Node receiver,
      Node index,
      A arg) {
    apply(receiver, arg);
    apply(index, arg);
    return null;
  }

  @override
  R visitIndexSet(
      SendSet node,
      Node receiver,
      Node index,
      Node rhs,
      A arg) {
    apply(receiver, arg);
    apply(index, arg);
    apply(rhs, arg);
    return null;
  }

  @override
  R visitIs(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R visitIsNot(
      Send node,
      Node expression,
      DartType type,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R visitLocalFunctionGet(
      Send node,
      LocalFunctionElement function,
      A arg) {
    return null;
  }

  @override
  R visitLocalFunctionInvoke(
      Send node,
      LocalFunctionElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitLocalVariableCompound(
      Send node,
      LocalVariableElement variable,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitLocalVariableGet(
      Send node,
      LocalVariableElement variable,
      A arg) {
    return null;
  }

  @override
  R visitLocalVariableInvoke(
      Send node,
      LocalVariableElement variable,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitLocalVariablePostfix(
      Send node,
      LocalVariableElement variable,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitLocalVariablePrefix(
      Send node,
      LocalVariableElement variable,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitLocalVariableSet(
      SendSet node,
      LocalVariableElement variable,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitLogicalAnd(
      Send node,
      Node left,
      Node right,
      A arg) {
    apply(left, arg);
    apply(right, arg);
    return null;
  }

  @override
  R visitLogicalOr(
      Send node,
      Node left,
      Node right,
      A arg) {
    apply(left, arg);
    apply(right, arg);
    return null;
  }

  @override
  R visitNot(
      Send node,
      Node expression,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R visitNotEquals(
      Send node,
      Node left,
      Node right,
      A arg) {
    apply(left, arg);
    apply(right, arg);
    return null;
  }

  @override
  R visitParameterCompound(
      Send node,
      ParameterElement parameter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitParameterGet(
      Send node,
      ParameterElement parameter,
      A arg) {
    return null;
  }

  @override
  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) {
    return null;
  }

  @override
  R visitStaticFunctionInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitStaticFunctionIncompatibleInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitStaticGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return null;
  }

  @override
  R visitStaticGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitStaticGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitStaticGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitStaticGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitStaticMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitStaticMethodSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitStaticMethodSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitStaticSetterSet(
      SendSet node,
      FunctionElement setter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperBinary(
      Send node,
      FunctionElement function,
      BinaryOperator operator,
      Node argument,
      A arg) {
    apply(argument, arg);
    return null;
  }

  @override
  R visitSuperCompoundIndexSet(
      SendSet node,
      FunctionElement getter,
      FunctionElement setter,
      Node index,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    apply(argument, arg);
    return null;
  }

  @override
  R visitSuperFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperFieldFieldPostfix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldFieldPrefix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitSuperFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperFieldSetterCompound(
      Send node,
      FieldElement field,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperFieldSetterPostfix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperFieldSetterPrefix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperGetterFieldCompound(
      Send node,
      FunctionElement getter,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperGetterFieldPostfix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperGetterFieldPrefix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return null;
  }

  @override
  R visitSuperGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitSuperGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  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,
      A arg) {
    apply(index, arg);
    return null;
  }

  @override
  R visitSuperIndexSet(
      SendSet node,
      FunctionElement function,
      Node index,
      Node rhs,
      A arg) {
    apply(index, arg);
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperMethodGet(
      Send node,
      MethodElement method,
      A arg) {
    return null;
  }

  @override
  R visitSuperMethodInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitSuperMethodIncompatibleInvoke(
      Send node,
      MethodElement method,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitSuperMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperMethodSetterPostfix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitSuperNotEquals(
      Send node,
      FunctionElement function,
      Node argument,
      A arg) {
    apply(argument, arg);
    return null;
  }

  @override
  R visitSuperSetterSet(
      SendSet node,
      FunctionElement setter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitSuperUnary(
      Send node,
      UnaryOperator operator,
      FunctionElement function,
      A arg) {
    return null;
  }

  @override
  R visitThisGet(Identifier node, A arg) {
    return null;
  }

  @override
  R visitThisInvoke(
      Send node,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitThisPropertyCompound(
      Send node,
      AssignmentOperator operator,
      Node rhs,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitThisPropertyGet(
      Send node,
      Selector selector,
      A arg) {
    return null;
  }

  @override
  R visitThisPropertyInvoke(
      Send node,
      NodeList arguments,
      Selector selector,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitThisPropertyPostfix(
      Send node,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return null;
  }

  @override
  R visitThisPropertyPrefix(
      Send node,
      IncDecOperator operator,
      Selector getterSelector,
      Selector setterSelector,
      A arg) {
    return null;
  }

  @override
  R visitThisPropertySet(
      SendSet node,
      Selector selector,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTopLevelFieldCompound(
      Send node,
      FieldElement field,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTopLevelFieldGet(
      Send node,
      FieldElement field,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelFieldInvoke(
      Send node,
      FieldElement field,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitTopLevelFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelFieldSet(
      SendSet node,
      FieldElement field,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTopLevelFunctionGet(
      Send node,
      MethodElement function,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelFunctionInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitTopLevelFunctionIncompatibleInvoke(
      Send node,
      MethodElement function,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitTopLevelGetterGet(
      Send node,
      FunctionElement getter,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelGetterInvoke(
      Send node,
      FunctionElement getter,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R visitTopLevelGetterSetterCompound(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTopLevelGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelMethodSetterCompound(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTopLevelMethodSetterPostfix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitTopLevelSetterSet(
      SendSet node,
      FunctionElement setter,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R errorTypeVariableTypeLiteralCompound(
      Send node,
      TypeVariableElement element,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTypeVariableTypeLiteralGet(
      Send node,
      TypeVariableElement element,
      A arg) {
    return null;
  }

  @override
  R visitTypeVariableTypeLiteralInvoke(
      Send node,
      TypeVariableElement element,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorTypeVariableTypeLiteralPostfix(
      Send node,
      TypeVariableElement element,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorTypeVariableTypeLiteralPrefix(
      Send node,
      TypeVariableElement element,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorTypedefTypeLiteralCompound(
      Send node,
      ConstantExpression constant,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitTypedefTypeLiteralGet(
      Send node,
      ConstantExpression constant,
      A arg) {
    return null;
  }

  @override
  R visitTypedefTypeLiteralInvoke(
      Send node,
      ConstantExpression constant,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorTypedefTypeLiteralPostfix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorTypedefTypeLiteralPrefix(
      Send node,
      ConstantExpression constant,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R visitUnary(
      Send node,
      UnaryOperator operator,
      Node expression,
      A arg) {
    apply(expression, arg);
    return null;
  }

  @override
  R errorUnresolvedCompound(
      Send node,
      Element element,
      AssignmentOperator operator,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  R visitUnresolvedGet(
      Send node,
      Element element,
      A arg) {
    return null;
  }

  @override
  R visitUnresolvedInvoke(
      Send node,
      Element element,
      NodeList arguments,
      Selector selector,
      A arg) {
    apply(arguments, arg);
    return null;
  }

  @override
  R errorUnresolvedPostfix(
      Send node,
      Element element,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorUnresolvedPrefix(
      Send node,
      Element element,
      IncDecOperator operator,
      A arg) {
    return null;
  }

  @override
  R errorUnresolvedSet(
      Send node,
      Element element,
      Node rhs,
      A arg) {
    apply(rhs, arg);
    return null;
  }

  @override
  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 visitUnresolvedSuperBinary(
      Send node,
      Element element,
      BinaryOperator operator,
      Node argument,
      A arg) {
    apply(argument, arg);
    return null;
  }

  @override
  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,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    apply(index, arg);
    return null;
  }

  @override
  R visitUnresolvedSuperGetterIndexPrefix(
      Send node,
      Element element,
      Node index,
      IncDecOperator operator,
      A 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;
  }

  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 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;
  }
}

/// [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);
  }
}

/// Mixin that groups all `visitSuperXPrefix`, `visitSuperXPostfix` methods by
/// delegating calls to `handleSuperXPostfixPrefix` methods.
///
/// This mixin is useful for the cases where super prefix/postfix expression are
/// handled uniformly.
abstract class BaseImplementationOfSuperIncDecsMixin<R, A>
    implements SemanticSendVisitor<R, A> {
  R handleSuperFieldFieldPostfixPrefix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleSuperFieldSetterPostfixPrefix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleSuperGetterFieldPostfixPrefix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleSuperGetterSetterPostfixPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleSuperMethodSetterPostfixPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleSuperIndexPostfixPrefix(
      Send node,
      FunctionElement indexFunction,
      FunctionElement indexSetFunction,
      Node index,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleUnresolvedSuperGetterIndexPostfixPrefix(
      Send node,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  R handleUnresolvedSuperSetterIndexPostfixPrefix(
      Send node,
      FunctionElement indexFunction,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg,
      {bool isPrefix});

  @override
  R visitSuperFieldFieldPostfix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldFieldPostfixPrefix(
        node, readField, writtenField, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperFieldFieldPrefix(
      Send node,
      FieldElement readField,
      FieldElement writtenField,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldFieldPostfixPrefix(
        node, readField, writtenField, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperFieldPostfix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldFieldPostfixPrefix(
        node, field, field, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperFieldPrefix(
      Send node,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldFieldPostfixPrefix(
        node, field, field, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperFieldSetterPostfix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldSetterPostfixPrefix(
        node, field, setter, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperFieldSetterPrefix(
      Send node,
      FieldElement field,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperFieldSetterPostfixPrefix(
        node, field, setter, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperGetterFieldPostfix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return handleSuperGetterFieldPostfixPrefix(
        node, getter, field, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperGetterFieldPrefix(
      Send node,
      FunctionElement getter,
      FieldElement field,
      IncDecOperator operator,
      A arg) {
    return handleSuperGetterFieldPostfixPrefix(
        node, getter, field, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperGetterSetterPostfix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperGetterSetterPostfixPrefix(
        node, getter, setter, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperGetterSetterPrefix(
      Send node,
      FunctionElement getter,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperGetterSetterPostfixPrefix(
        node, getter, setter, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperMethodSetterPostfix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperMethodSetterPostfixPrefix(
        node, method, setter, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperMethodSetterPrefix(
      Send node,
      FunctionElement method,
      FunctionElement setter,
      IncDecOperator operator,
      A arg) {
    return handleSuperMethodSetterPostfixPrefix(
        node, method, setter, operator, arg, isPrefix: true);
  }

  @override
  R visitSuperIndexPostfix(
      Send node,
      FunctionElement indexFunction,
      FunctionElement indexSetFunction,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleSuperIndexPostfixPrefix(
        node, indexFunction, indexSetFunction,
        index, operator, arg, isPrefix: false);
  }

  @override
  R visitSuperIndexPrefix(
      Send node,
      FunctionElement indexFunction,
      FunctionElement indexSetFunction,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleSuperIndexPostfixPrefix(
        node, indexFunction, indexSetFunction,
        index, operator, arg, isPrefix: true);
  }

  @override
  R visitUnresolvedSuperGetterIndexPostfix(
      Send node,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleUnresolvedSuperGetterIndexPostfixPrefix(
        node, element, index, operator, arg, isPrefix: false);
  }

  @override
  R visitUnresolvedSuperGetterIndexPrefix(
      Send node,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleUnresolvedSuperGetterIndexPostfixPrefix(
        node, element, index, operator, arg, isPrefix: true);
  }

  @override
  R visitUnresolvedSuperSetterIndexPostfix(
      Send node,
      MethodElement indexFunction,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleUnresolvedSuperSetterIndexPostfixPrefix(
        node, indexFunction, element, index, operator, arg, isPrefix: false);
  }

  @override
  R visitUnresolvedSuperSetterIndexPrefix(
      Send node,
      MethodElement indexFunction,
      Element element,
      Node index,
      IncDecOperator operator,
      A arg) {
    return handleUnresolvedSuperSetterIndexPostfixPrefix(
        node, indexFunction, element, index, operator, arg, isPrefix: true);
  }
}

/// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
/// delegating calls to the `handleConstructorInvoke` method.
///
/// This mixin is useful for the cases where all constructor invocations are
/// handled uniformly.
abstract class BaseImplementationOfNewMixin<R, A>
    implements SemanticSendVisitor<R, A> {

  R handleConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      DartType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg);

  R visitGenerativeConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }

  R visitRedirectingGenerativeConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }

  R visitFactoryConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }

  R visitRedirectingFactoryConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      ConstructorElement effectiveTarget,
      InterfaceType effectiveTargetType,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }

  R visitUnresolvedConstructorInvoke(
      NewExpression node,
      Element constructor,
      DartType type,
      NodeList arguments,
      Selector selector,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, selector.callStructure, arg);
  }

  R visitUnresolvedClassConstructorInvoke(
      NewExpression node,
      Element element,
      DartType type,
      NodeList arguments,
      Selector selector,
      A arg) {
    return handleConstructorInvoke(
        node, element, type, arguments, selector.callStructure, arg);
  }

  R visitAbstractClassConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }
  R visitUnresolvedRedirectingFactoryConstructorInvoke(
      NewExpression node,
      ConstructorElement constructor,
      InterfaceType type,
      NodeList arguments,
      CallStructure callStructure,
      A arg) {
    return handleConstructorInvoke(
        node, constructor, type, arguments, callStructure, arg);
  }
}