All strong mode cleaning of dart2js.

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js.semantics_visitor;
 
 /// 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:
@@ skipping 135 matching lines @@
   }
 }
 
 /// 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) {
+  R bulkHandlePrefix(SendSet node, A arg) {
     return bulkHandleNode(node, "Prefix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node, Node receiver, Name name, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   R visitIfNotNullDynamicPropertyPrefix(
@@ skipping 19 matching lines @@
     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) {
+  R visitStaticGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticMethodSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPrefix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperFieldPrefix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperIndexPrefix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPrefix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexPrefix(SendSet node, MethodElement getter,
       Element element, Node index, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitUnresolvedSuperIndexPrefix(
       Send node, 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) {
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitThisPropertyPrefix(
       Send node, Name name, IncDecOperator operator, 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) {
+  R visitTopLevelGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitClassTypeLiteralPrefix(
       Send node, ConstantExpression constant, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
@@ skipping 26 matching lines @@
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitStaticMethodPrefix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelMethodPrefix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitUnresolvedPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitFinalLocalVariablePrefix(Send node, LocalVariableElement variable,
       IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitFinalParameterPrefix(
       Send node, ParameterElement parameter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitFinalStaticFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitFinalSuperFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitSuperMethodPrefix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitFinalTopLevelFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitUnresolvedSuperPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPrefix(SendSet node, GetterElement getter,
       Element element, 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) {
+  R bulkHandlePostfix(SendSet node, A arg) {
     return bulkHandleNode(node, "Postfix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node, Node receiver, Name name, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
@@ skipping 19 matching lines @@
     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) {
+  R visitStaticGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitStaticMethodSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticMethodSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperFieldFieldPostfix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPostfix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperFieldPostfix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPostfix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperIndexPostfix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPostfix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexPostfix(SendSet node, MethodElement getter,
       Element element, Node index, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitUnresolvedSuperIndexPostfix(
       Send node, 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) {
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitThisPropertyPostfix(
       Send node, Name name, IncDecOperator operator, 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) {
+  R visitTopLevelGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitClassTypeLiteralPostfix(
       Send node, ConstantExpression constant, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
@@ skipping 26 matching lines @@
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitUnresolvedTopLevelGetterPostfix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitStaticMethodPostfix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   R visitToplevelMethodPostfix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitUnresolvedPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitFinalLocalVariablePostfix(Send node, LocalVariableElement variable,
       IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitFinalParameterPostfix(
       Send node, ParameterElement parameter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitFinalStaticFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitFinalSuperFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitSuperMethodPostfix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitFinalTopLevelFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelMethodPostfix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPostfix(SendSet node, GetterElement getter,
       Element element, 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) {
+  R bulkHandleCompound(SendSet node, A arg) {
     return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyCompound(Send node, Node receiver, Name name,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
@@ skipping 14 matching lines @@
     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) {
+  R visitStaticGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement 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) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+  R visitSuperGetterFieldCompound(Send node, GetterElement 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) {
+  R visitSuperGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitThisPropertyCompound(
       Send node, Name name, AssignmentOperator operator, Node rhs, 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) {
+  R visitTopLevelGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitFinalParameterCompound(Send node, ParameterElement parameter,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
@@ skipping 56 matching lines @@
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitUnresolvedTopLevelGetterCompound(Send node, Element element,
       MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitStaticMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitTopLevelMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedCompound(Send node, Element element,
+  R visitUnresolvedCompound(Send node, ErroneousElement element,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitSuperFieldFieldCompound(Send node, FieldElement readField,
       FieldElement writtenField, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitSuperMethodCompound(Send node, FunctionElement method,
+  R visitSuperMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitUnresolvedSuperCompound(Send node, Element element,
       AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitUnresolvedSuperGetterCompound(SendSet node, Element element,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleCompound(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXSetIfNull` methods of [SemanticSendVisitor]
 /// by delegating to a bulk handler.
 ///
 /// Use this mixin to provide a trivial implementation for all `xSetIfNull`
 /// methods.
 abstract class SetIfNullBulkMixin<R, A>
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
-  R bulkHandleSetIfNull(Send node, A arg) {
+  R bulkHandleSetIfNull(SendSet node, A arg) {
     return bulkHandleNode(node, "If null assignment `#` unhandled.", arg);
   }
 
   @override
   R visitClassTypeLiteralSetIfNull(
       Send node, ConstantExpression constant, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
@@ skipping 61 matching lines @@
       Send node, ParameterElement parameter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitStaticFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
-  R visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitStaticGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitStaticMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitStaticMethodSetterSetIfNull(
       Send node, MethodElement method, MethodElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperFieldFieldSetIfNull(Send node, FieldElement readField,
       FieldElement writtenField, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperFieldSetterSetIfNull(
-      Send node, FieldElement field, FunctionElement setter, Node rhs, A arg) {
+      Send node, FieldElement field, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperGetterFieldSetIfNull(
-      Send node, FunctionElement getter, FieldElement field, Node rhs, A arg) {
+      Send node, GetterElement getter, FieldElement field, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitSuperGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitThisPropertySetIfNull(Send node, Name name, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitTopLevelFieldSetIfNull(
       Send node, FieldElement field, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
-  R visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitTopLevelGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitTypedefTypeLiteralSetIfNull(
       Send node, ConstantExpression constant, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedSetIfNull(Send node, Element element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedStaticGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedStaticSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedSuperGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedSuperSetIfNull(Send node, Element element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedSuperSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedTopLevelGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedTopLevelSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexSetIfNull(SendSet node, Element element,
       MethodElement setter, Node index, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexSetIfNull(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexSetIfNull(SendSet node, MethodElement getter,
       Element element, Node index, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 
   @override
   R visitUnresolvedSuperIndexSetIfNull(
       Send node, Element element, Node index, Node rhs, A arg) {
     return bulkHandleSetIfNull(node, arg);
   }
 }
@@ skipping 79 matching lines @@
     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) {
+  R visitStaticGetterInvoke(Send node, GetterElement 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) {
+  R visitSuperGetterInvoke(Send node, GetterElement 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
@@ skipping 26 matching lines @@
     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,
+  R visitTopLevelGetterInvoke(Send node, GetterElement 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);
   }
 
@@ skipping 15 matching lines @@
     return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitUnresolvedSuperInvoke(Send node, Element function, NodeList arguments,
       Selector selector, A arg) {
     return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitStaticSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitStaticSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg) {
     return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitSuperSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitSuperSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg) {
     return bulkHandleInvoke(node, arg);
   }
 
   @override
-  R visitTopLevelSetterInvoke(Send node, FunctionElement setter,
+  R visitTopLevelSetterInvoke(Send node, SetterElement setter,
       NodeList arguments, CallStructure callStructure, 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.
@@ skipping 43 matching lines @@
   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) {
+  R visitStaticGetterGet(Send node, GetterElement 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) {
+  R visitSuperGetterGet(Send node, GetterElement 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, Name name, 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) {
+  R visitTopLevelGetterGet(Send node, GetterElement getter, A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTypeVariableTypeLiteralGet(
       Send node, TypeVariableElement element, A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
@@ skipping 10 matching lines @@
   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);
   }
 
   @override
-  R visitStaticSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitStaticSetterGet(Send node, SetterElement setter, A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitSuperSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitSuperSetterGet(Send node, SetterElement setter, A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
-  R visitTopLevelSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitTopLevelSetterGet(Send node, SetterElement setter, 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) {
+  R bulkHandleSet(SendSet node, A arg) {
     return bulkHandleNode(node, "Assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node, Node receiver, Name name, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
@@ skipping 13 matching lines @@
       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) {
+  R visitStaticSetterSet(SendSet node, SetterElement 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) {
+  R visitSuperSetterSet(SendSet node, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitThisPropertySet(SendSet node, Name name, 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) {
+      SendSet node, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitClassTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitDynamicTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitFinalLocalVariableSet(
       SendSet node, LocalVariableElement variable, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
@@ skipping 19 matching lines @@
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitLocalFunctionSet(
       SendSet node, LocalFunctionElement function, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitStaticFunctionSet(Send node, MethodElement function, Node rhs, A arg) {
+  R visitStaticFunctionSet(
+      SendSet node, MethodElement function, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitStaticGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+  R visitStaticGetterSet(SendSet node, GetterElement getter, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitSuperGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg) {
+  R visitSuperGetterSet(SendSet node, GetterElement getter, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitSuperMethodSet(Send node, MethodElement method, Node rhs, A arg) {
+  R visitSuperMethodSet(SendSet node, MethodElement method, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTopLevelFunctionSet(
-      Send node, MethodElement function, Node rhs, A arg) {
+      SendSet node, MethodElement function, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTopLevelGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+      SendSet node, GetterElement getter, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTypeVariableTypeLiteralSet(
       SendSet node, TypeVariableElement element, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTypedefTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
-  R visitUnresolvedSet(Send node, Element element, Node rhs, A arg) {
+  R visitUnresolvedSet(SendSet node, Element element, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitUnresolvedSuperSet(Send node, Element element, Node rhs, A arg) {
     return bulkHandleSet(node, arg);
   }
 }
 
 /// Mixin that implements all `visitXIndexSet` methods of [SemanticSendVisitor]
@@ skipping 14 matching lines @@
   }
 
   @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,
+      MethodElement getter,
+      MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleIndexSet(node, arg);
   }
 
   @override
   R visitUnresolvedSuperGetterCompoundIndexSet(
       SendSet node,
@@ skipping 25 matching lines @@
   }
 
   @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) {
+      SendSet node, ErroneousElement 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>
@@ skipping 17 matching lines @@
   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) {
+  R visitSuperBinary(Send node, MethodElement function, BinaryOperator operator,
+      Node argument, A arg) {
     return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitSuperEquals(
-      Send node, FunctionElement function, Node argument, A arg) {
+  R visitSuperEquals(Send node, MethodElement function, Node argument, A arg) {
     return bulkHandleBinary(node, arg);
   }
 
   @override
   R visitSuperNotEquals(
-      Send node, FunctionElement function, Node argument, A arg) {
+      Send node, MethodElement function, Node argument, A arg) {
     return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitSuperIndex(Send node, FunctionElement function, Node index, A arg) {
+  R visitSuperIndex(Send node, MethodElement function, Node index, A arg) {
     return bulkHandleBinary(node, arg);
   }
 
   @override
-  R visitUnresolvedSuperBinary(Send node, FunctionElement function,
+  R visitUnresolvedSuperBinary(Send node, Element 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) {
+  R visitUnresolvedSuperIndex(Send node, Element 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) {
+      Send node, UnaryOperator operator, MethodElement 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) {
+      Send node, UnaryOperator operator, Element 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>
@@ skipping 39 matching lines @@
 ///
 /// 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) {
+  R visitSuperBinary(Send node, MethodElement function, BinaryOperator operator,
+      Node argument, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperCompoundIndexSet(
       SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
+      MethodElement getter,
+      MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperEquals(
-      Send node, FunctionElement function, Node argument, A arg) {
+  R visitSuperEquals(Send node, MethodElement 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,
+  R visitSuperFieldFieldPostfix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPrefix(SendSet 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) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperFieldPrefix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet 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) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPostfix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+  R visitSuperGetterFieldCompound(Send node, GetterElement getter,
       FieldElement field, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterGet(Send node, FunctionElement getter, A arg) {
+  R visitSuperGetterGet(Send node, GetterElement getter, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitSuperGetterInvoke(Send node, GetterElement 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) {
+  R visitSuperGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperNotEquals(
-      Send node, FunctionElement function, Node argument, A arg) {
+      Send node, MethodElement function, Node argument, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
-  R visitSuperSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg) {
+  R visitSuperSetterSet(SendSet node, SetterElement setter, Node rhs, A arg) {
     return bulkHandleSuper(node, arg);
   }
 
   @override
   R visitSuperUnary(
-      Send node, UnaryOperator operator, FunctionElement function, A arg) {
+      Send node, UnaryOperator operator, MethodElement 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
@@ skipping 360 matching lines @@
 ///
 /// 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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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);
   }
 }
 
@@ skipping 191 matching lines @@
 
   @override
   R errorInvalidIndexPostfix(Send node, ErroneousElement error, Node index,
       IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
   R visitClassTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitDynamicTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitFinalLocalVariableCompound(Send node, LocalVariableElement variable,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
@@ skipping 73 matching lines @@
   }
 
   @override
   R visitLocalFunctionSet(
       SendSet node, LocalFunctionElement function, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticFunctionSet(Send node, MethodElement function, Node rhs, A arg) {
+  R visitStaticFunctionSet(
+      SendSet node, MethodElement function, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+  R visitStaticGetterSet(SendSet node, GetterElement getter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitStaticSetterGet(Send node, SetterElement setter, A arg) {
     return null;
   }
 
   @override
-  R visitStaticSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitStaticSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg) {
+  R visitSuperGetterSet(SendSet node, GetterElement getter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperMethodSet(Send node, MethodElement method, Node rhs, A arg) {
+  R visitSuperMethodSet(SendSet node, MethodElement method, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitSuperSetterGet(Send node, SetterElement setter, A arg) {
     return null;
   }
 
   @override
-  R visitSuperSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitSuperSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitTopLevelFunctionSet(
-      Send node, MethodElement function, Node rhs, A arg) {
+      SendSet node, MethodElement function, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTopLevelGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+      SendSet node, GetterElement getter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTopLevelSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitTopLevelSetterGet(Send node, SetterElement setter, A arg) {
     return null;
   }
 
   @override
-  R visitTopLevelSetterInvoke(Send node, FunctionElement setter,
+  R visitTopLevelSetterInvoke(Send node, SetterElement setter,
       NodeList arguments, CallStructure callStructure, A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitTypeVariableTypeLiteralSet(
       SendSet node, TypeVariableElement element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTypedefTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg) {
+      SendSet node, TypeConstantExpression 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;
   }
 
@@ skipping 426 matching lines @@
   }
 
   @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) {
+  R visitStaticGetterGet(Send node, GetterElement getter, A arg) {
     return null;
   }
 
   @override
-  R visitStaticGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitStaticGetterInvoke(Send node, GetterElement 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) {
+  R visitStaticGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitStaticGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitStaticGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitStaticMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement 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) {
+  R visitStaticMethodSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticMethodSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitStaticSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg) {
+  R visitStaticSetterSet(SendSet node, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperBinary(Send node, FunctionElement function,
-      BinaryOperator operator, Node argument, A arg) {
+  R visitSuperBinary(Send node, MethodElement function, BinaryOperator operator,
+      Node argument, A arg) {
     apply(argument, arg);
     return null;
   }
 
   @override
   R visitSuperCompoundIndexSet(
       SendSet node,
-      FunctionElement getter,
-      FunctionElement setter,
+      MethodElement getter,
+      MethodElement 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) {
+  R visitSuperEquals(Send node, MethodElement 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,
+  R visitSuperFieldFieldPostfix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPrefix(SendSet 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) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitSuperFieldPrefix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet 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) {
+      SetterElement 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) {
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+  R visitSuperGetterFieldCompound(Send node, GetterElement getter,
       FieldElement field, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterGet(Send node, FunctionElement getter, A arg) {
+  R visitSuperGetterGet(Send node, GetterElement getter, A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitSuperGetterInvoke(Send node, GetterElement 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) {
+  R visitSuperGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperIndex(Send node, FunctionElement function, Node index, A arg) {
+  R visitSuperIndex(Send node, MethodElement 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;
@@ skipping 13 matching lines @@
 
   @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) {
+      SetterElement 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) {
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitSuperNotEquals(
-      Send node, FunctionElement function, Node argument, A arg) {
+      Send node, MethodElement function, Node argument, A arg) {
     apply(argument, arg);
     return null;
   }
 
   @override
-  R visitSuperSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg) {
+  R visitSuperSetterSet(SendSet node, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperUnary(
-      Send node, UnaryOperator operator, FunctionElement function, A arg) {
+      Send node, UnaryOperator operator, MethodElement function, A arg) {
     return null;
   }
 
   @override
   R visitThisGet(Identifier node, A arg) {
     return null;
   }
 
   @override
   R visitThisInvoke(
@@ skipping 89 matching lines @@
   }
 
   @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) {
+  R visitTopLevelGetterGet(Send node, GetterElement getter, A arg) {
     return null;
   }
 
   @override
-  R visitTopLevelGetterInvoke(Send node, FunctionElement getter,
+  R visitTopLevelGetterInvoke(Send node, GetterElement 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) {
+  R visitTopLevelGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitTopLevelGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitTopLevelGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitTopLevelGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitTopLevelMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement 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) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitTopLevelSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg) {
+      SendSet node, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTypeVariableTypeLiteralCompound(Send node, TypeVariableElement element,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
@@ skipping 54 matching lines @@
     return null;
   }
 
   @override
   R visitUnary(Send node, UnaryOperator operator, Node expression, A arg) {
     apply(expression, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedCompound(Send node, Element element,
+  R visitUnresolvedCompound(Send node, ErroneousElement 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 visitUnresolvedPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitUnresolvedPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSet(Send node, Element element, Node rhs, A arg) {
+  R visitUnresolvedSet(SendSet 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) {
+      SendSet node, ErroneousElement element, Node index, Node rhs, A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperGetterCompoundIndexSet(
       SendSet node,
       Element element,
       MethodElement setter,
@@ skipping 35 matching lines @@
     return null;
   }
 
   @override
   R visitUnresolvedSuperUnary(
       Send node, UnaryOperator operator, Element element, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPostfix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexPostfix(SendSet node, MethodElement getter,
       Element element, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperIndexPostfix(
       Send node, Element element, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPrefix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexPrefix(SendSet node, MethodElement getter,
       Element element, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperIndexPrefix(
       Send node, Element element, Node index, IncDecOperator operator, A arg) {
     apply(index, arg);
     return null;
@@ skipping 11 matching lines @@
   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,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
   R visitSuperIndexPrefix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     apply(index, arg);
     return null;
   }
 
   @override
   R errorInvalidSetIfNull(Send node, ErroneousElement error, Node rhs, A arg) {
     apply(rhs, arg);
@@ skipping 86 matching lines @@
     return null;
   }
 
   @override
   R visitStaticFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitStaticGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitStaticMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
@@ skipping 13 matching lines @@
   }
 
   @override
   R visitSuperFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperFieldSetterSetIfNull(
-      Send node, FieldElement field, FunctionElement setter, Node rhs, A arg) {
+      Send node, FieldElement field, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperGetterFieldSetIfNull(
-      Send node, FunctionElement getter, FieldElement field, Node rhs, A arg) {
+      Send node, GetterElement getter, FieldElement field, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitSuperGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitThisPropertySetIfNull(Send node, Name name, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTopLevelFieldSetIfNull(
       Send node, FieldElement field, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitTopLevelGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTopLevelMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTypeVariableTypeLiteralSetIfNull(
       Send node, TypeVariableElement element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
@@ skipping 13 matching lines @@
 
   @override
   R visitUnresolvedStaticGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedStaticSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperSetIfNull(Send node, Element element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedTopLevelGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedTopLevelSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitConstConstructorInvoke(
       NewExpression node, ConstructedConstantExpression constant, A arg) {
     return null;
   }
 
@@ skipping 140 matching lines @@
   }
 
   @override
   R visitUnresolvedTopLevelGetterCompound(Send node, Element element,
       MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitStaticMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedStaticGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitStaticMethodPrefix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitTopLevelMethodPrefix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitUnresolvedStaticGetterPostfix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitUnresolvedTopLevelGetterPostfix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitStaticMethodPostfix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return null;
   }
 
@@ skipping 59 matching lines @@
     return null;
   }
 
   @override
   R visitFinalSuperFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitSuperMethodCompound(Send node, FunctionElement method,
+  R visitSuperMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperMethodPostfix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitSuperMethodPrefix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitFinalTopLevelFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitFinalTopLevelFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitTopLevelMethodCompound(Send node, FunctionElement method,
+  R visitTopLevelMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperCompound(Send node, Element element,
       AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitUnresolvedSuperPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitUnresolvedSuperGetterCompound(SendSet node, Element element,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPostfix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPrefix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return null;
   }
 
   @override
   R visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, A arg) {
     apply(receiver, arg);
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitSuperIndexSetIfNull(SendSet node, MethodElement getter,
       MethodElement setter, Node index, Node rhs, A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexSetIfNull(SendSet node, Element element,
       MethodElement setter, Node index, Node rhs, A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
-  R visitUnresolvedSuperSetterIndexSetIfNull(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexSetIfNull(SendSet node, MethodElement getter,
       Element element, Node index, Node rhs, A arg) {
     apply(index, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitUnresolvedSuperIndexSetIfNull(
       Send node, Element element, Node index, Node rhs, A arg) {
     apply(index, arg);
@@ skipping 282 matching lines @@
   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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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) {
+      FunctionExpression node, GetterElement 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;
@@ skipping 58 matching lines @@
   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 handleStaticGetterGet(Send node, GetterElement getter, A arg);
 
-  R handleStaticGetterSet(Send node, FunctionElement getter, Node rhs, A arg);
+  R handleStaticGetterSet(SendSet node, GetterElement getter, Node rhs, A arg);
 
-  R handleStaticGetterInvoke(Send node, FunctionElement getter,
+  R handleStaticGetterInvoke(Send node, GetterElement getter,
       NodeList arguments, CallStructure callStructure, A arg);
 
-  R handleStaticSetterGet(SendSet node, FunctionElement setter, A arg);
+  R handleStaticSetterGet(SendSet node, SetterElement setter, A arg);
 
-  R handleStaticSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg);
+  R handleStaticSetterSet(SendSet node, SetterElement setter, Node rhs, A arg);
 
-  R handleStaticSetterInvoke(Send node, FunctionElement setter,
+  R handleStaticSetterInvoke(Send node, SetterElement setter,
       NodeList arguments, CallStructure callStructure, A arg);
 
   R handleFinalStaticFieldSet(
       SendSet node, FieldElement field, Node rhs, A arg);
 
   R handleStaticFunctionSet(
       SendSet node, MethodElement function, Node rhs, A arg);
 
   @override
   R visitStaticFieldGet(Send node, FieldElement field, A arg) {
@@ skipping 24 matching lines @@
   }
 
   @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) {
+  R visitStaticGetterGet(Send node, GetterElement getter, A arg) {
     return handleStaticGetterGet(node, getter, arg);
   }
 
   @override
-  R visitStaticGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg) {
+  R visitStaticGetterInvoke(Send node, GetterElement getter, NodeList arguments,
+      CallStructure callStructure, A arg) {
     return handleStaticGetterInvoke(
         node, getter, arguments, callStructure, arg);
   }
 
   @override
-  R visitStaticSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg) {
+  R visitStaticSetterSet(SendSet node, SetterElement setter, Node rhs, A arg) {
     return handleStaticSetterSet(node, setter, 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,
@@ skipping 19 matching lines @@
   }
 
   @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) {
+  R visitTopLevelGetterGet(Send node, GetterElement getter, A arg) {
     return handleStaticGetterGet(node, getter, arg);
   }
 
   @override
   R visitTopLevelGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+      SendSet node, GetterElement getter, Node rhs, A arg) {
     return handleStaticGetterSet(node, getter, rhs, arg);
   }
 
   @override
-  R visitTopLevelGetterInvoke(Send node, FunctionElement getter,
+  R visitTopLevelGetterInvoke(Send node, GetterElement getter,
       NodeList arguments, CallStructure callStructure, A arg) {
     return handleStaticGetterInvoke(
         node, getter, arguments, callStructure, arg);
   }
 
   @override
   R visitTopLevelSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg) {
+      SendSet node, SetterElement setter, Node rhs, A arg) {
     return handleStaticSetterSet(node, setter, rhs, arg);
   }
 
   @override
-  R visitStaticSetterInvoke(Send node, FunctionElement setter,
+  R visitStaticSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg) {
+    return handleStaticSetterInvoke(
+        node, setter, arguments, callStructure, arg);
+  }
+
+  @override
+  R visitTopLevelSetterInvoke(Send node, SetterElement setter,
       NodeList arguments, CallStructure callStructure, A arg) {
     return handleStaticSetterInvoke(
         node, setter, arguments, callStructure, arg);
   }
 
   @override
-  R visitTopLevelSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg) {
-    return handleStaticSetterInvoke(
-        node, setter, arguments, callStructure, arg);
-  }
-
-  @override
-  R visitStaticSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitStaticSetterGet(Send node, SetterElement setter, A arg) {
     return handleStaticSetterGet(node, setter, arg);
   }
 
   @override
-  R visitStaticGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg) {
+  R visitStaticGetterSet(SendSet node, GetterElement getter, Node rhs, A arg) {
     return handleStaticGetterSet(node, getter, rhs, arg);
   }
 
   @override
-  R visitTopLevelSetterGet(Send node, FunctionElement setter, A arg) {
+  R visitTopLevelSetterGet(Send node, SetterElement setter, A arg) {
     return handleStaticSetterGet(node, setter, arg);
   }
 
   @override
   R visitFinalStaticFieldSet(
       SendSet node, FieldElement field, Node rhs, A arg) {
     return handleFinalStaticFieldSet(node, field, rhs, arg);
   }
 
   @override
   R visitFinalTopLevelFieldSet(
       SendSet node, FieldElement field, Node rhs, A arg) {
     return handleFinalStaticFieldSet(node, field, rhs, arg);
   }
 
   @override
-  R visitStaticFunctionSet(Send node, MethodElement function, Node rhs, A arg) {
+  R visitStaticFunctionSet(
+      SendSet node, MethodElement function, Node rhs, A arg) {
     return handleStaticFunctionSet(node, function, rhs, arg);
   }
 
   @override
   R visitTopLevelFunctionSet(
-      Send node, MethodElement function, Node rhs, A arg) {
+      SendSet node, MethodElement function, Node rhs, A arg) {
     return handleStaticFunctionSet(node, function, rhs, arg);
   }
 }
 
 /// Mixin that groups all compounds visitors `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 BaseImplementationOfStaticCompoundsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   R handleStaticFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg);
 
   R handleStaticFieldPostfixPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg,
       {bool isPrefix});
 
-  R handleStaticGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+  R handleStaticGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
-  R handleStaticGetterSetterPostfixPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg,
+  R handleStaticGetterSetterPostfixPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleStaticMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
-  R handleStaticMethodSetterPostfixPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg,
+  R handleStaticMethodSetterPostfixPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleFinalStaticFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg);
 
   R handleFinalStaticFieldPostfixPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleStaticMethodCompound(Send node, FunctionElement method,
       AssignmentOperator operator, Node rhs, A arg);
 
   R handleStaticMethodPostfixPrefix(
       Send node, FunctionElement method, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleUnresolvedStaticGetterCompound(Send node, Element element,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   R handleUnresolvedStaticGetterPostfixPrefix(Send node, Element element,
-      FunctionElement setter, IncDecOperator operator, A arg,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
-  R handleUnresolvedStaticSetterCompound(Send node, FunctionElement getter,
+  R handleUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg);
 
-  R handleUnresolvedStaticSetterPostfixPrefix(Send node, FunctionElement getter,
+  R handleUnresolvedStaticSetterPostfixPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   @override
   R visitStaticFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticFieldCompound(node, field, operator, rhs, 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 visitStaticGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitStaticGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitStaticGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitStaticGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement 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) {
+  R visitStaticMethodSetterPostfix(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitStaticMethodSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticMethodSetterPostfixPrefix(
         node, getter, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitTopLevelFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticFieldCompound(node, field, operator, rhs, 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 visitTopLevelGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitTopLevelGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitTopLevelGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement 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) {
+  R visitTopLevelGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement 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) {
+      SetterElement 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) {
+      SetterElement 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) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticMethodSetterPostfixPrefix(
         node, method, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitFinalStaticFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleFinalStaticFieldCompound(node, field, operator, rhs, arg);
   }
@@ skipping 27 matching lines @@
 
   @override
   R visitStaticMethodPrefix(
       Send node, FunctionElement method, IncDecOperator operator, A arg) {
     return handleStaticMethodPostfixPrefix(node, method, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitUnresolvedStaticGetterCompound(Send node, Element element,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleUnresolvedStaticGetterCompound(
         node, element, setter, operator, rhs, arg);
   }
 
   @override
   R visitUnresolvedStaticGetterPostfix(Send node, Element element,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleUnresolvedStaticGetterPostfixPrefix(
         node, element, setter, operator, arg,
         isPrefix: false);
   }
 
   @override
   R visitUnresolvedStaticGetterPrefix(Send node, Element element,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleUnresolvedStaticGetterPostfixPrefix(
         node, element, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
-  R visitUnresolvedStaticSetterCompound(Send node, FunctionElement getter,
+  R visitUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return handleUnresolvedStaticSetterCompound(
         node, getter, element, operator, rhs, arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterPostfix(Send node, FunctionElement getter,
+  R visitUnresolvedStaticSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedStaticSetterPostfixPrefix(
         node, getter, element, operator, arg,
         isPrefix: false);
   }
 
   @override
-  R visitUnresolvedStaticSetterPrefix(Send node, FunctionElement getter,
+  R visitUnresolvedStaticSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedStaticSetterPostfixPrefix(
         node, getter, element, operator, arg,
         isPrefix: true);
   }
 }
 
 /// Mixin that groups all non-compound `visitLocalX` and `visitParameterX`
 /// methods by delegating calls to `handleLocalX` methods.
 ///
@@ skipping 571 matching lines @@
   }
 
   @override
   R visitFinalStaticFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, field, CompoundGetter.FIELD, null,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitStaticGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitStaticGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitStaticMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, method, CompoundGetter.METHOD, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitTopLevelFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.FIELD, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitFinalTopLevelFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, field, CompoundGetter.FIELD, null,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitTopLevelGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitTopLevelGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitTopLevelMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, method, CompoundGetter.METHOD, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitSuperFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.FIELD, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitFinalSuperFieldCompound(Send node, FieldElement field,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitSuperGetterSetterCompound(Send node, FunctionElement getter,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitSuperGetterSetterCompound(Send node, GetterElement getter,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitSuperMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, method, CompoundGetter.METHOD, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitSuperFieldSetterCompound(Send node, FieldElement field,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg) {
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, field, CompoundGetter.FIELD, setter,
         CompoundSetter.SETTER, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+  R visitSuperGetterFieldCompound(Send node, GetterElement getter,
       FieldElement field, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, getter, CompoundGetter.GETTER, field,
         CompoundSetter.FIELD, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitClassTypeLiteralCompound(Send node, ConstantExpression constant,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleTypeLiteralConstantCompounds(
         node, constant, new AssignmentCompound(operator, rhs), arg);
@@ skipping 69 matching lines @@
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitStaticGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
-  R visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticMethodSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
   R visitTopLevelFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitTopLevelGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitTopLevelGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
   R visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
   R visitSuperFieldPrefix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPrefix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         readField,
         CompoundGetter.FIELD,
         writtenField,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
@@ skipping 76 matching lines @@
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitStaticGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
-  R visitStaticMethodSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitStaticMethodSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitTopLevelFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitTopLevelGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitTopLevelGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitTopLevelMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitSuperFieldPostfix(
-      Send node, FieldElement field, IncDecOperator operator, A arg) {
+      SendSet node, FieldElement field, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperFieldFieldPostfix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPostfix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         readField,
         CompoundGetter.FIELD,
         writtenField,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperFieldSetterPostfix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         field,
         CompoundGetter.FIELD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
-  R visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         field,
         CompoundSetter.FIELD,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg) {
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
@@ skipping 45 matching lines @@
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
@@ skipping 19 matching lines @@
         method,
         CompoundGetter.METHOD,
         method,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitUnresolvedPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
@@ skipping 17 matching lines @@
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
@@ skipping 19 matching lines @@
         method,
         CompoundGetter.METHOD,
         method,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
   R visitUnresolvedPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      Send node, ErroneousElement element, IncDecOperator operator, A arg) {
     return handleStaticCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
@@ skipping 17 matching lines @@
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new AssignmentCompound(operator, rhs),
         arg);
   }
 
   @override
-  R visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitStaticMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitTopLevelMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitUnresolvedCompound(Send node, Element element,
+  R visitUnresolvedCompound(Send node, ErroneousElement element,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleStaticCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new AssignmentCompound(operator, rhs),
         arg);
   }
@@ skipping 89 matching lines @@
         node,
         field,
         CompoundGetter.FIELD,
         field,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitSuperMethodCompound(Send node, FunctionElement method,
+  R visitSuperMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
   R visitSuperMethodPostfix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         method,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitSuperMethodPrefix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg) {
+      Send node, MethodElement method, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         method,
         CompoundGetter.METHOD,
         method,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
@@ skipping 31 matching lines @@
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new AssignmentCompound(operator, rhs),
         arg);
   }
 
   @override
   R visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
   R visitUnresolvedSuperPrefix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg) {
+  R visitUnresolvedSuperGetterCompound(SendSet node, Element element,
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new AssignmentCompound(operator, rhs),
         arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         element,
         CompoundGetter.UNRESOLVED,
         setter,
         CompoundSetter.SETTER,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperCompounds(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, new AssignmentCompound(operator, rhs), arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPostfix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg);
   }
 
   @override
-  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPrefix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleSuperCompounds(
         node,
         getter,
         CompoundGetter.GETTER,
         element,
         CompoundSetter.INVALID,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
@@ skipping 116 matching lines @@
         isSetterValid: true);
   }
 
   @override
   R visitStaticFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.FIELD, rhs, arg);
   }
 
   @override
-  R visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitStaticGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitStaticMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, rhs, arg);
   }
@@ skipping 13 matching lines @@
   }
 
   @override
   R visitSuperFieldSetIfNull(Send node, FieldElement field, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.FIELD, rhs, arg);
   }
 
   @override
   R visitSuperFieldSetterSetIfNull(
-      Send node, FieldElement field, FunctionElement setter, Node rhs, A arg) {
+      Send node, FieldElement field, SetterElement setter, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, field, CompoundGetter.FIELD, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitSuperGetterFieldSetIfNull(
-      Send node, FunctionElement getter, FieldElement field, Node rhs, A arg) {
+      Send node, GetterElement getter, FieldElement field, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, getter, CompoundGetter.GETTER, field,
         CompoundSetter.FIELD, rhs, arg);
   }
 
   @override
-  R visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitSuperGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitSuperMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, method, CompoundGetter.METHOD, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitThisPropertySetIfNull(Send node, Name name, Node rhs, A arg) {
     return handleDynamicSetIfNulls(node, null, name, rhs, arg);
   }
 
   @override
   R visitTopLevelFieldSetIfNull(
       Send node, FieldElement field, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, field, CompoundGetter.FIELD, field,
         CompoundSetter.FIELD, rhs, arg);
   }
 
   @override
-  R visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg) {
+  R visitTopLevelGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, getter, CompoundGetter.GETTER, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitTopLevelMethodSetIfNull(
       Send node, FunctionElement method, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, method, CompoundGetter.METHOD, method,
         CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg) {
+      SetterElement setter, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, method, CompoundGetter.METHOD, setter,
         CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitTypedefTypeLiteralSetIfNull(
       Send node, ConstantExpression constant, Node rhs, A arg) {
     return handleTypeLiteralConstantSetIfNulls(node, constant, rhs, arg);
   }
 
   @override
   R visitUnresolvedSetIfNull(Send node, Element element, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, element, CompoundGetter.UNRESOLVED,
         element, CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitUnresolvedStaticGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, element, CompoundGetter.UNRESOLVED,
         setter, CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitUnresolvedStaticSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitUnresolvedSuperGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, element, CompoundGetter.UNRESOLVED,
         setter, CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitUnresolvedSuperSetIfNull(Send node, Element element, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, element, CompoundGetter.UNRESOLVED,
         element, CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitUnresolvedSuperSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return handleSuperSetIfNulls(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, rhs, arg);
   }
 
   @override
   R visitUnresolvedTopLevelGetterSetIfNull(
       Send node, Element element, MethodElement setter, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, element, CompoundGetter.UNRESOLVED,
         setter, CompoundSetter.SETTER, rhs, arg);
   }
 
   @override
   R visitUnresolvedTopLevelSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg) {
+      Send node, GetterElement getter, Element element, Node rhs, A arg) {
     return handleStaticSetIfNulls(node, getter, CompoundGetter.GETTER, element,
         CompoundSetter.INVALID, rhs, arg);
   }
 }
 
 /// Simplified handling of indexed compound assignments and prefix/postfix
 /// expressions.
 abstract class BaseImplementationOfIndexCompoundsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   /// Handle a dynamic index compounds, like `receiver[index] += rhs` or
   /// `--receiver[index]`.
   R handleIndexCompounds(
       SendSet node, Node receiver, Node index, CompoundRhs rhs, A arg);
 
   /// Handle a super index compounds, like `super[index] += rhs` or
   /// `--super[index]`.
   R handleSuperIndexCompounds(SendSet node, Element indexFunction,
       Element indexSetFunction, Node index, CompoundRhs rhs, A arg,
       {bool isGetterValid, bool isSetterValid});
 
   @override
   R visitSuperCompoundIndexSet(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, indexSetFunction,
         index, new AssignmentCompound(operator, rhs), arg,
         isGetterValid: true, isSetterValid: true);
   }
 
   @override
   R visitSuperIndexPostfix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, indexSetFunction,
         index, new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
         isGetterValid: true, isSetterValid: true);
   }
 
   @override
   R visitSuperIndexPrefix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, indexSetFunction,
         index, new IncDecCompound(CompoundKind.PREFIX, operator), arg,
         isGetterValid: true, isSetterValid: true);
   }
 
   @override
   R visitUnresolvedSuperGetterCompoundIndexSet(
-      Send node,
+      SendSet node,
       Element indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, indexSetFunction,
         index, new AssignmentCompound(operator, rhs), arg,
         isGetterValid: false, isSetterValid: true);
   }
 
   @override
   R visitUnresolvedSuperSetterCompoundIndexSet(
-      Send node,
-      FunctionElement indexFunction,
+      SendSet node,
+      MethodElement indexFunction,
       Element indexSetFunction,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, indexSetFunction,
         index, new AssignmentCompound(operator, rhs), arg,
         isGetterValid: true, isSetterValid: false);
   }
 
   @override
-  R visitUnresolvedSuperCompoundIndexSet(Send node, Element element, Node index,
-      AssignmentOperator operator, Node rhs, A arg) {
+  R visitUnresolvedSuperCompoundIndexSet(SendSet node, Element element,
+      Node index, AssignmentOperator operator, Node rhs, A arg) {
     return handleSuperIndexCompounds(node, element, element, index,
         new AssignmentCompound(operator, rhs), arg,
         isGetterValid: false, isSetterValid: false);
   }
 
   @override
   R visitUnresolvedSuperGetterIndexPostfix(
-      Send node,
+      SendSet node,
       Element element,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, element, indexSetFunction, index,
         new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
         isGetterValid: false, isSetterValid: true);
   }
 
   @override
   R visitUnresolvedSuperGetterIndexPrefix(
-      Send node,
+      SendSet node,
       Element element,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, element, indexSetFunction, index,
         new IncDecCompound(CompoundKind.PREFIX, operator), arg,
         isGetterValid: false, isSetterValid: true);
   }
 
   @override
   R visitUnresolvedSuperSetterIndexPostfix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, element, index,
         new IncDecCompound(CompoundKind.POSTFIX, operator), arg,
         isGetterValid: true, isSetterValid: false);
   }
 
   @override
   R visitUnresolvedSuperSetterIndexPrefix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexCompounds(node, indexFunction, element, index,
         new IncDecCompound(CompoundKind.PREFIX, operator), arg,
         isGetterValid: true, isSetterValid: false);
   }
 
@@ skipping 45 matching lines @@
 
   @override
   R visitSuperIndexSetIfNull(Send node, FunctionElement indexFunction,
       FunctionElement indexSetFunction, Node index, Node rhs, A arg) {
     return handleSuperIndexSetIfNull(
         node, indexFunction, indexSetFunction, index, rhs, arg,
         isGetterValid: true, isSetterValid: true);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element indexFunction,
-      FunctionElement indexSetFunction, Node index, Node rhs, A arg) {
+  R visitUnresolvedSuperGetterIndexSetIfNull(
+      SendSet node,
+      Element indexFunction,
+      FunctionElement indexSetFunction,
+      Node index,
+      Node rhs,
+      A arg) {
     return handleSuperIndexSetIfNull(
         node, indexFunction, indexSetFunction, index, rhs, arg,
         isGetterValid: false, isSetterValid: true);
   }
 
   @override
   R visitUnresolvedSuperSetterIndexSetIfNull(
-      Send node,
-      FunctionElement indexFunction,
+      SendSet node,
+      MethodElement indexFunction,
       Element indexSetFunction,
       Node index,
       Node rhs,
       A arg) {
     return handleSuperIndexSetIfNull(
         node, indexFunction, indexSetFunction, index, rhs, arg,
         isGetterValid: true, isSetterValid: false);
   }
 
   @override
   R visitUnresolvedSuperIndexSetIfNull(
       Send node, Element element, Node index, Node rhs, A arg) {
     return handleSuperIndexSetIfNull(node, element, element, index, rhs, arg,
         isGetterValid: false, isSetterValid: false);
   }
 }
 
 /// 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,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
-  R handleSuperGetterFieldPostfixPrefix(Send node, FunctionElement getter,
+  R handleSuperGetterFieldPostfixPrefix(Send node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg,
       {bool isPrefix});
 
-  R handleSuperGetterSetterPostfixPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg,
+  R handleSuperGetterSetterPostfixPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleSuperMethodSetterPostfixPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg,
+      SetterElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleSuperIndexPostfixPrefix(
       Send node,
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg,
       {bool isPrefix});
@@ skipping 24 matching lines @@
       {bool isPrefix});
 
   R handleUnresolvedSuperPostfixPrefix(
       Send node, Element element, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   R handleUnresolvedSuperGetterPostfixPrefix(Send node, Element element,
       MethodElement setter, IncDecOperator operator, A arg,
       {bool isPrefix});
 
-  R handleUnresolvedSuperSetterPostfixPrefix(Send node, MethodElement getter,
+  R handleUnresolvedSuperSetterPostfixPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg,
       {bool isPrefix});
 
   @override
-  R visitSuperFieldFieldPostfix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPostfix(SendSet 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,
+  R visitSuperFieldFieldPrefix(SendSet 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) {
+      SendSet 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) {
+      SendSet 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) {
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement 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) {
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperFieldSetterPostfixPrefix(
         node, field, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg) {
     return handleSuperGetterFieldPostfixPrefix(
         node, getter, field, operator, arg,
         isPrefix: false);
   }
 
   @override
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement 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) {
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement 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) {
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement 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) {
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement 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) {
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleSuperMethodSetterPostfixPrefix(
         node, method, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitSuperIndexPostfix(
       Send node,
-      FunctionElement indexFunction,
-      FunctionElement indexSetFunction,
+      MethodElement indexFunction,
+      MethodElement 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,
+      MethodElement indexFunction,
+      MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleSuperIndexPostfixPrefix(
         node, indexFunction, indexSetFunction, index, operator, arg,
         isPrefix: true);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPostfix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperGetterIndexPostfixPrefix(
         node, element, setter, index, operator, arg,
         isPrefix: false);
   }
 
   @override
-  R visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPrefix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperGetterIndexPostfixPrefix(
         node, element, setter, index, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitUnresolvedSuperSetterIndexPostfix(
-      Send node,
+      SendSet 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,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleUnresolvedSuperSetterIndexPostfixPrefix(
         node, indexFunction, element, index, operator, arg,
         isPrefix: true);
   }
 
@@ skipping 36 matching lines @@
 
   @override
   R visitSuperMethodPrefix(
       Send node, MethodElement method, IncDecOperator operator, A arg) {
     return handleSuperMethodPostfixPrefix(node, method, operator, arg,
         isPrefix: true);
   }
 
   @override
   R visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, A arg) {
+      SendSet node, Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperPostfixPrefix(node, element, operator, arg,
         isPrefix: false);
   }
 
   @override
   R visitUnresolvedSuperPrefix(
       Send node, Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperPostfixPrefix(node, element, operator, arg,
         isPrefix: true);
   }
 
   @override
-  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperGetterPostfixPrefix(
         node, element, setter, operator, arg,
         isPrefix: false);
   }
 
   @override
-  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg) {
+  R visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperGetterPostfixPrefix(
         node, element, setter, operator, arg,
         isPrefix: true);
   }
 
   @override
-  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPostfix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperSetterPostfixPrefix(
         node, getter, element, operator, arg,
         isPrefix: false);
   }
 
   @override
-  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPrefix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg) {
     return handleUnresolvedSuperSetterPostfixPrefix(
         node, getter, element, operator, arg,
         isPrefix: true);
   }
 }
 
 /// Mixin that groups the non-constant `visitXConstructorInvoke` methods by
 /// delegating calls to the `handleConstructorInvoke` method.
 ///
@@ skipping 94 matching lines @@
       NewExpression node,
       ConstructorElement constructor,
       ResolutionInterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 }