All strong mode cleaning of dart2js.

pkg/compiler/lib/src/resolution/semantic_visitor.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.
 
 library dart2js.semantics_visitor;
 
 import '../common.dart';
 import '../constants/expressions.dart';
 import '../elements/elements.dart';
 import '../elements/names.dart';
@@ skipping 503 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///       foo(a, b) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperMethodSet(Send node, MethodElement method, Node rhs, A arg);
+  R visitSuperMethodSet(SendSet node, MethodElement method, Node rhs, A arg);
 
   /// Getter call to the super [getter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperGetterGet(Send node, FunctionElement getter, A arg);
+  R visitSuperGetterGet(Send node, GetterElement getter, A arg);
 
   /// Getter call the super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() => super.foo;
   ///     }
   ///
-  R visitSuperSetterGet(Send node, FunctionElement setter, A arg);
+  R visitSuperSetterGet(Send node, SetterElement setter, A arg);
 
   /// Setter call to the super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg);
+  R visitSuperSetterSet(SendSet node, SetterElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the super [getter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo = rhs; }
   ///     }
   ///
-  R visitSuperGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg);
+  R visitSuperGetterSet(SendSet node, GetterElement getter, Node rhs, A arg);
 
   /// Invocation of the super [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get foo => null;
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
-  R visitSuperGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg);
+  R visitSuperGetterInvoke(Send node, GetterElement getter, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Invocation of the super [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set foo(_) {}
   ///     }
   ///     class C extends B {
   ///        m() { super.foo(null, 42; }
   ///     }
   ///
-  R visitSuperSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg);
+  R visitSuperSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Invocation of a [expression] with [arguments].
   ///
   /// For instance:
   ///
   ///     m() => (a, b){}(null, 42);
   ///
   R visitExpressionInvoke(Send node, Node expression, NodeList arguments,
       CallStructure callStructure, A arg);
 
@@ skipping 79 matching lines @@
 
   /// Assignment of [rhs] to the static [function].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static foo(a, b) {}
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticFunctionSet(Send node, MethodElement function, Node rhs, A arg);
+  R visitStaticFunctionSet(
+      SendSet node, MethodElement function, Node rhs, A arg);
 
   /// Getter call to the static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticGetterGet(Send node, FunctionElement getter, A arg);
+  R visitStaticGetterGet(Send node, GetterElement getter, A arg);
 
   /// Getter call the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() => C.foo;
   ///
-  R visitStaticSetterGet(Send node, FunctionElement setter, A arg);
+  R visitStaticSetterGet(Send node, SetterElement setter, A arg);
 
   /// Setter call to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticSetterSet(SendSet node, FunctionElement setter, Node rhs, A arg);
+  R visitStaticSetterSet(SendSet node, SetterElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() { C.foo = rhs; }
   ///
-  R visitStaticGetterSet(SendSet node, FunctionElement getter, Node rhs, A arg);
+  R visitStaticGetterSet(SendSet node, GetterElement getter, Node rhs, A arg);
 
   /// Invocation of the static [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get foo => null;
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
-  R visitStaticGetterInvoke(Send node, FunctionElement getter,
-      NodeList arguments, CallStructure callStructure, A arg);
+  R visitStaticGetterInvoke(Send node, GetterElement getter, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Invocation of the static [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set foo(_) {}
   ///     }
   ///     m() { C.foo(null, 42; }
   ///
-  R visitStaticSetterInvoke(Send node, FunctionElement setter,
-      NodeList arguments, CallStructure callStructure, A arg);
+  R visitStaticSetterInvoke(Send node, SetterElement setter, NodeList arguments,
+      CallStructure callStructure, A arg);
 
   /// Read of the top level [field].
   ///
   /// For instance:
   ///
   ///     var foo;
   ///     m() => foo;
   ///
   R visitTopLevelFieldGet(Send node, FieldElement field, A arg);
 
@@ skipping 58 matching lines @@
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the top level [function].
   ///
   /// For instance:
   ///
   ///     foo(a, b) {};
   ///     m() { foo = rhs; }
   ///
   R visitTopLevelFunctionSet(
-      Send node, MethodElement function, Node rhs, A arg);
+      SendSet node, MethodElement function, Node rhs, A arg);
 
   /// Getter call to the top level [getter].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() => foo;
   ///
-  R visitTopLevelGetterGet(Send node, FunctionElement getter, A arg);
+  R visitTopLevelGetterGet(Send node, GetterElement getter, A arg);
 
   /// Getter call the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m() => foo;
   ///
-  R visitTopLevelSetterGet(Send node, FunctionElement setter, A arg);
+  R visitTopLevelSetterGet(Send node, SetterElement setter, A arg);
 
   /// Setter call to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m() { foo = rhs; }
   ///
-  R visitTopLevelSetterSet(
-      SendSet node, FunctionElement setter, Node rhs, A arg);
+  R visitTopLevelSetterSet(SendSet node, SetterElement setter, Node rhs, A arg);
 
   /// Assignment of [rhs] to the top level [getter].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() { foo = rhs; }
   ///
-  R visitTopLevelGetterSet(
-      SendSet node, FunctionElement getter, Node rhs, A arg);
+  R visitTopLevelGetterSet(SendSet node, GetterElement getter, Node rhs, A arg);
 
   /// Invocation of the top level [getter] with [arguments].
   ///
   /// For instance:
   ///
   ///     get foo => null;
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelGetterInvoke(Send node, FunctionElement getter,
+  R visitTopLevelGetterInvoke(Send node, GetterElement getter,
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Invocation of the top level [setter] with [arguments].
   ///
   /// For instance:
   ///
   ///     set foo(_) {};
   ///     m() { foo(null, 42); }
   ///
-  R visitTopLevelSetterInvoke(Send node, FunctionElement setter,
+  R visitTopLevelSetterInvoke(Send node, SetterElement setter,
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Read of the type literal for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C;
   ///
   R visitClassTypeLiteralGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the type literal for class [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C(null, 42);
   ///
   R visitClassTypeLiteralInvoke(Send node, ConstantExpression constant,
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() { C = rhs; }
   ///
   R visitClassTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg);
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg);
 
   /// Read of the type literal for typedef [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => F;
   ///
   R visitTypedefTypeLiteralGet(Send node, ConstantExpression constant, A arg);
 
   /// Invocation of the type literal for typedef [element] with [arguments].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() => F(null, 42);
   ///
   R visitTypedefTypeLiteralInvoke(Send node, ConstantExpression constant,
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for typedef [element].
   ///
   /// For instance:
   ///
   ///     typedef F();
   ///     m() { F = rhs; }
   ///
   R visitTypedefTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg);
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg);
 
   /// Read of the type literal for type variable [element].
   ///
   /// For instance:
   ///
   ///     class C<T> {
   ///       m() => T;
   ///     }
   ///
   R visitTypeVariableTypeLiteralGet(
@@ skipping 39 matching lines @@
   R visitDynamicTypeLiteralInvoke(Send node, ConstantExpression constant,
       NodeList arguments, CallStructure callStructure, A arg);
 
   /// Assignment of [rhs] to the type literal for `dynamic`.
   ///
   /// For instance:
   ///
   ///     m() { dynamic = rhs; }
   ///
   R visitDynamicTypeLiteralSet(
-      SendSet node, ConstantExpression constant, Node rhs, A arg);
+      SendSet node, TypeConstantExpression constant, Node rhs, A arg);
 
   /// Binary expression `left operator right` where [operator] is a user
   /// definable operator. Binary expressions using operator `==` are handled
   /// by [visitEquals] and index operations `a[b]` are handled by [visitIndex].
   ///
   /// For instance:
   ///
   ///     add(a, b) => a + b;
   ///     sub(a, b) => a - b;
   ///     mul(a, b) => a * b;
   ///
   R visitBinary(
       Send node, Node left, BinaryOperator operator, Node right, A arg);
 
   /// Binary expression `super operator argument` where [operator] is a user
   /// definable operator implemented on a superclass by [function]. Binary
   /// expressions using operator `==` are handled by [visitSuperEquals].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator +(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super + a;
   ///     }
   ///
-  R visitSuperBinary(Send node, FunctionElement function,
-      BinaryOperator operator, Node argument, A arg);
+  R visitSuperBinary(Send node, MethodElement function, BinaryOperator operator,
+      Node argument, A arg);
 
   /// Binary operation on the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super + 42;
   ///     }
@@ skipping 34 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a];
   ///     }
   ///
-  R visitSuperIndex(Send node, FunctionElement function, Node index, A arg);
+  R visitSuperIndex(Send node, MethodElement function, Node index, A arg);
 
   /// Index expression `super[index]` where 'operator []' is unresolved.
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C extends B {
   ///       m(a) => super[a];
   ///     }
   ///
@@ skipping 51 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a) => --super[a];
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexPrefix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPrefix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg);
 
   /// Postfix operation on an index expression `super[index] operator` where
   /// 'operator []' is unresolved, 'operator []=' is defined by [setter], and
   /// the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator []=(a, b) {}
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexPostfix(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexPostfix(SendSet node, Element element,
       MethodElement setter, Node index, IncDecOperator operator, A arg);
 
   /// Prefix operation on an index expression `operator super[index]` where
   /// 'operator []' is implemented on a superclass by [indexFunction] and
   /// 'operator []=' is unresolved and the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => 42;
   ///     }
   ///     class C extends B {
   ///       m(a) => --super[a];
   ///     }
   ///
   R visitUnresolvedSuperSetterIndexPrefix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       A arg);
 
   /// Postfix operation on an index expression `super[index] operator` where
   /// 'operator []' is implemented on a superclass by [indexFunction] and
   /// 'operator []=' is unresolved and the operation is defined by [operator].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](_) => 42;
   ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
   R visitUnresolvedSuperSetterIndexPostfix(
-      Send node,
+      SendSet node,
       MethodElement indexFunction,
       Element element,
       Node index,
       IncDecOperator operator,
       A arg);
 
   /// Prefix operation on an index expression `super[index] operator` where
   /// both 'operator []' and 'operator []=' are unresolved and the operation is
   /// defined by [operator].
   ///
@@ skipping 39 matching lines @@
   /// For instance:
   ///
   ///     class B {
   ///       operator +(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super + a;
   ///     }
   ///
   R visitSuperNotEquals(
-      Send node, FunctionElement function, Node argument, A arg);
+      Send node, MethodElement function, Node argument, A arg);
 
   /// Binary expression `left == right`.
   ///
   /// For instance:
   ///
   ///     eq(a, b) => a == b;
   ///
   R visitEquals(Send node, Node left, Node right, A arg);
 
   /// Binary expression `super == argument` where `==` is implemented on a
   /// superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator ==(_) => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => super == a;
   ///     }
   ///
-  R visitSuperEquals(Send node, FunctionElement function, Node argument, A arg);
+  R visitSuperEquals(Send node, MethodElement function, Node argument, A arg);
 
   /// Unary expression `operator expression` where [operator] is a user
   /// definable operator.
   ///
   /// For instance:
   ///
   ///     neg(a, b) => -a;
   ///     comp(a, b) => ~a;
   ///
   R visitUnary(Send node, UnaryOperator operator, Node expression, A arg);
 
   /// Unary expression `operator super` where [operator] is a user definable
   /// operator implemented on a superclass by [function].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator -() => null;
   ///     }
   ///     class C extends B {
   ///       m(a) => -super;
   ///     }
   ///
   R visitSuperUnary(
-      Send node, UnaryOperator operator, FunctionElement function, A arg);
+      Send node, UnaryOperator operator, MethodElement function, A arg);
 
   /// Unary operation on the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => -super;
   ///     }
@@ skipping 37 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] = 42;
   ///     }
   ///
   R visitUnresolvedSuperIndexSet(
-      Send node, Element element, Node index, Node rhs, A arg);
+      SendSet node, ErroneousElement element, Node index, Node rhs, A arg);
 
   /// If-null, ??, expression with operands [left] and [right].
   ///
   /// For instance:
   ///
   ///     m() => left ?? right;
   ///
   R visitIfNull(Send node, Node left, Node right, A arg);
 
   /// Logical and, &&, expression with operands [left] and [right].
@@ skipping 168 matching lines @@
   /// static [getter] and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m(rhs) => o += rhs;
   ///     }
   ///
-  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);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// static [method], that is, closurizing [method], and writing to a static
   /// [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m(rhs) => o += rhs;
   ///     }
   ///
   R visitStaticMethodSetterCompound(Send node, MethodElement method,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a top level
   /// [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m(rhs) => field += rhs;
   ///
   R visitTopLevelFieldCompound(Send node, FieldElement field,
@@ skipping 12 matching lines @@
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [getter] and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m(rhs) => o += rhs;
   ///
-  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);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [method], that is, closurizing [method], and writing to a top
   /// level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m(rhs) => o += rhs;
   ///
   R visitTopLevelMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [method], that is, closurizing [method], and writing to an
   /// unresolved setter.
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o += rhs;
   ///
-  R visitTopLevelMethodCompound(Send node, FunctionElement method,
+  R visitTopLevelMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a super
   /// [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
@@ skipping 155 matching lines @@
   /// the [setter], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m(rhs) => o ??= rhs;
   ///     }
   ///
-  R visitStaticGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg);
+  R visitStaticGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined by
   /// [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m(rhs) => o ??= rhs;
   ///     }
   ///
   R visitStaticMethodSetterSetIfNull(
-      Send node, MethodElement method, MethodElement setter, Node rhs, A arg);
+      Send node, MethodElement method, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static [method]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [method] is
   /// `null`. The behavior is thus equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o ??= rhs;
   ///
@@ skipping 26 matching lines @@
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m(rhs) => o ??= rhs;
   ///
-  R visitTopLevelGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg);
+  R visitTopLevelGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m(rhs) => o ??= rhs;
   ///
-  R visitTopLevelMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg);
+  R visitTopLevelMethodSetterSetIfNull(
+      Send node, FunctionElement method, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level [method]. That is,
   /// [rhs] is only evaluated and assigned, if the value of the [method] is
   /// `null`. The behavior is thus equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     m(rhs) => o ??= rhs;
   ///
@@ skipping 57 matching lines @@
   /// For instance:
   ///
   ///     class B {
   ///       get o => 0;
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
-  R visitSuperGetterSetterSetIfNull(Send node, FunctionElement getter,
-      FunctionElement setter, Node rhs, A arg);
+  R visitSuperGetterSetterSetIfNull(
+      Send node, GetterElement getter, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [method] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [method] is `null`. The behavior is thus
   /// equivalent to a closurization of [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
-  R visitSuperMethodSetterSetIfNull(Send node, FunctionElement method,
-      FunctionElement setter, Node rhs, A arg);
+  R visitSuperMethodSetterSetIfNull(
+      Send node, FunctionElement method, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super [method].
   /// That is, [rhs] is only evaluated and assigned, if the value of
   /// the [method] is `null`. The behavior is thus equivalent to a closurization
   /// of [method].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
@@ skipping 13 matching lines @@
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitUnresolvedSuperGetterSetIfNull(
-      Send node, Element element, MethodElement setter, Node rhs, A arg);
+      Send node, Element element, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the super property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitUnresolvedSuperSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg);
+      Send node, GetterElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [field] and [setter]. That is, [rhs] is only evaluated and assigned to
   /// the [setter], if the value of the [field] is `null`.
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitSuperFieldSetterSetIfNull(
-      Send node, FieldElement field, FunctionElement setter, Node rhs, A arg);
+      Send node, FieldElement field, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] and [field]. That is, [rhs] is only evaluated and assigned to
   /// the [field], if the value of the [getter] is `null`.
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       get o => 0;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o ??= rhs;
   ///     }
   ///
   R visitSuperGetterFieldSetIfNull(
-      Send node, FunctionElement getter, FieldElement field, Node rhs, A arg);
+      Send node, GetterElement getter, FieldElement field, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to an unresolved super property.
   /// That is, [rhs] is only evaluated and assigned, if the value of the
   /// unresolved property is `null`. The behavior is thus equivalent to a no
   /// such method error.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
@@ skipping 10 matching lines @@
   /// error.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo ??= 42;
   ///
   R visitUnresolvedStaticGetterSetIfNull(
-      Send node, Element element, MethodElement setter, Node rhs, A arg);
+      Send node, Element element, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [setter] with no corresponding getter. That is, [rhs] is only evaluated
   /// and assigned to the [setter], if the value of the unresolved getter is
   /// `null`. The behavior is thus equivalent to a no such method error.
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo ??= 42;
   ///
   R visitUnresolvedTopLevelGetterSetIfNull(
-      Send node, Element element, MethodElement setter, Node rhs, A arg);
+      Send node, Element element, SetterElement setter, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the static property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo ??= 42;
   ///
   R visitUnresolvedStaticSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg);
+      Send node, GetterElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to the top level property defined
   /// by [getter] with no corresponding setter. That is, [rhs] is only evaluated
   /// and assigned to the unresolved setter, if the value of the [getter] is
   /// `null`.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo ??= 42;
   ///
   R visitUnresolvedTopLevelSetterSetIfNull(
-      Send node, MethodElement getter, Element element, Node rhs, A arg);
+      Send node, GetterElement getter, Element element, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to an unresolved property.
   /// That is, [rhs] is only evaluated and assigned, if the value of the
   /// unresolved property is `null`. The behavior is thus equivalent to a no
   /// such method error.
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m1() => unresolved ??= 42;
@@ skipping 82 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => ++super.unresolved;
   ///     }
   ///
   R visitUnresolvedSuperPrefix(
-      Send node, Element element, IncDecOperator operator, A arg);
+      SendSet node, Element element, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on an unresolved super property.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.unresolved++;
   ///     }
   ///
   R visitUnresolvedSuperPostfix(
-      Send node, Element element, IncDecOperator operator, A arg);
+      SendSet node, Element element, IncDecOperator operator, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on an unresolved
   /// super property.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.unresolved += rhs;
@@ skipping 41 matching lines @@
   /// For instance:
   ///
   ///     class B {
   ///       get o => 0;
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  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);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [method], that is, closurizing [method], and writing to a super
   /// [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
   R visitSuperMethodSetterCompound(Send node, FunctionElement method,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading the
   /// closurized super [method] and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperMethodCompound(Send node, FunctionElement method,
+  R visitSuperMethodCompound(Send node, MethodElement method,
       AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from the
   /// non-existing super getter and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  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);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to the non-existing super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitUnresolvedSuperSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [field] and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
   R visitSuperFieldSetterCompound(Send node, FieldElement field,
-      FunctionElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var o;
   ///     }
   ///     class B extends A {
   ///       get o => 0;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.o += rhs;
   ///     }
   ///
-  R visitSuperGetterFieldCompound(Send node, FunctionElement getter,
+  R visitSuperGetterFieldCompound(Send node, GetterElement getter,
       FieldElement field, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m(rhs) => C += rhs;
   ///
@@ skipping 71 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] += 42;
   ///     }
   ///
   R visitUnresolvedSuperGetterCompoundIndexSet(
-      Send node,
+      SendSet node,
       Element element,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on a super
   /// class where the index getter is defined by [getter] but the index setter
   /// is undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index) => 42;
   ///     }
   ///     class C extends B {
   ///       m() => super[1] += 42;
   ///     }
   ///
   R visitUnresolvedSuperSetterCompoundIndexSet(
-      Send node,
+      SendSet node,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on a super
   /// class where the index getter and setter are undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] += 42;
   ///     }
   ///
-  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);
 
   /// If-null assignment expression of [rhs] to [index] on the index operators
   /// of [receiver].
   ///
   /// For instance:
   ///
   ///     m(receiver, index, rhs) => receiver[index] ??= rhs;
   ///
   R visitIndexSetIfNull(
       SendSet node, Node receiver, Node index, Node rhs, A arg);
@@ skipping 19 matching lines @@
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index, value) {}
   ///     }
   ///     class C extends B {
   ///       m() => super[1] ??= 42;
   ///     }
   ///
-  R visitUnresolvedSuperGetterIndexSetIfNull(Send node, Element element,
+  R visitUnresolvedSuperGetterIndexSetIfNull(SendSet node, Element element,
       MethodElement setter, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on a super class where
   /// the index getter is defined by [getter] but the index setter is undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       operator [](index) => 42;
   ///     }
   ///     class C extends B {
   ///       m() => super[1] ??= 42;
   ///     }
   ///
-  R visitUnresolvedSuperSetterIndexSetIfNull(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterIndexSetIfNull(SendSet node, MethodElement getter,
       Element element, Node index, Node rhs, A arg);
 
   /// If-null assignment expression of [rhs] to [index] on a super class where
   /// the index getter and setter are undefined.
   ///
   /// For instance:
   ///
   ///     class B {
   ///     }
   ///     class C extends B {
@@ skipping 126 matching lines @@
   /// writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => ++o;
   ///     }
   ///
-  R visitStaticGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitStaticGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a static [method], that is,
   /// closurizing [method], and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m() => ++o;
   ///     }
   ///
-  R visitStaticMethodSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitStaticMethodSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a top level [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m() => ++field;
   ///
   R visitTopLevelFieldPrefix(
       Send node, FieldElement field, IncDecOperator operator, A arg);
@@ skipping 10 matching lines @@
 
   /// Prefix expression with [operator] reading from a top level [getter] and
   /// writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m() => ++o;
   ///
-  R visitTopLevelGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitTopLevelGetterSetterPrefix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a top level [method], that
   /// is, closurizing [method], and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m() => ++o;
   ///
   R visitTopLevelMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
   R visitSuperFieldPrefix(
-      Send node, FieldElement field, IncDecOperator operator, A arg);
+      SendSet node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from the super field [readField]
   /// and writing to the different super field [writtenField].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperFieldFieldPrefix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPrefix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [field] and writing
   /// to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperFieldSetterPrefix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperFieldSetterPrefix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get field => 0;
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperGetterSetterPrefix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperGetterSetterPrefix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       get field => 0;
   ///     }
   ///     class C extends B {
   ///       m() => ++super.field;
   ///     }
   ///
-  R visitSuperGetterFieldPrefix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPrefix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
-  R visitSuperMethodSetterPrefix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperMethodSetterPrefix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   R visitSuperMethodPrefix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from an unresolved super getter
   /// and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+  R visitUnresolvedSuperGetterPrefix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42
   ///     }
   ///     class C extends B {
   ///       m() => ++super.o;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPrefix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] on a type literal for a class [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => ++C;
   ///
   R visitClassTypeLiteralPrefix(
@@ skipping 154 matching lines @@
   /// writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => o++;
   ///     }
   ///
-  R visitStaticGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitStaticGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a static [method], that
   /// is, closurizing [method], and writing to a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m() => o++;
   ///     }
   ///
-  R visitStaticMethodSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitStaticMethodSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a top level [field].
   ///
   /// For instance:
   ///
   ///     var field;
   ///     m() => field++;
   ///
   R visitTopLevelFieldPostfix(
       Send node, FieldElement field, IncDecOperator operator, A arg);
@@ skipping 10 matching lines @@
 
   /// Postfix expression with [operator] reading from a top level [getter] and
   /// writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     get o => 0;
   ///     set o(_) {}
   ///     m() => o++;
   ///
-  R visitTopLevelGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitTopLevelGetterSetterPostfix(Send node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a top level [method], that
   /// is, closurizing [method], and writing to a top level [setter].
   ///
   /// For instance:
   ///
   ///     o() {}
   ///     set o(_) {}
   ///     m() => o++;
   ///
   R visitTopLevelMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a super [field].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
   R visitSuperFieldPostfix(
-      Send node, FieldElement field, IncDecOperator operator, A arg);
+      SendSet node, FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from the super field
   /// [readField] and writing to the different super field [writtenField].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       final field;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperFieldFieldPostfix(Send node, FieldElement readField,
+  R visitSuperFieldFieldPostfix(SendSet node, FieldElement readField,
       FieldElement writtenField, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [field] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperFieldSetterPostfix(Send node, FieldElement field,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperFieldSetterPostfix(SendSet node, FieldElement field,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [getter] and
   /// writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get field => 0;
   ///       set field(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperGetterSetterPostfix(Send node, FunctionElement getter,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperGetterSetterPostfix(SendSet node, GetterElement getter,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [getter] and
   /// writing to a super [field].
   ///
   /// For instance:
   ///
   ///     class A {
   ///       var field;
   ///     }
   ///     class B extends A {
   ///       get field => 0;
   ///     }
   ///     class C extends B {
   ///       m() => super.field++;
   ///     }
   ///
-  R visitSuperGetterFieldPostfix(Send node, FunctionElement getter,
+  R visitSuperGetterFieldPostfix(SendSet node, GetterElement getter,
       FieldElement field, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
-  R visitSuperMethodSetterPostfix(Send node, FunctionElement method,
-      FunctionElement setter, IncDecOperator operator, A arg);
+  R visitSuperMethodSetterPostfix(SendSet node, FunctionElement method,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] reading from a super [method], that is,
   /// closurizing [method], and writing to an unresolved super.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       o() {}
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   R visitSuperMethodPostfix(
-      Send node, FunctionElement method, IncDecOperator operator, A arg);
+      Send node, MethodElement method, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from an unresolved super getter
   /// and writing to a super [setter].
   ///
   /// For instance:
   ///
   ///     class B {
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+  R visitUnresolvedSuperGetterPostfix(SendSet node, Element element,
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix expression with [operator] reading from a super [getter] and
   /// writing to an unresolved super setter.
   ///
   /// For instance:
   ///
   ///     class B {
   ///       get o => 42
   ///     }
   ///     class C extends B {
   ///       m() => super.o++;
   ///     }
   ///
   ///
-  R visitUnresolvedSuperSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedSuperSetterPostfix(SendSet node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Postfix expression with [operator] on a type literal for a class
   /// [element].
   ///
   /// For instance:
   ///
   ///     class C {}
   ///     m() => C++;
   ///
@@ skipping 93 matching lines @@
   ///     m4() => unresolved.foo = 42;
   ///     m5() => unresolved.Foo.bar = 42;
   ///     m6() => C.unresolved = 42;
   ///     m7() => prefix.C.unresolved = 42;
   ///     m8() => prefix?.unresolved = 42;
   ///     m9() => Unresolved?.foo = 42;
   ///     m10() => unresolved?.foo = 42;
   ///     m11() => unresolved?.Foo?.bar = 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R visitUnresolvedSet(Send node, Element element, Node rhs, A arg);
+  R visitUnresolvedSet(SendSet node, Element element, Node rhs, A arg);
 
   ///  Assignment of [rhs] to the unresolved super [element].
   ///
   /// For instance:
   ///
   ///     class B {}
   ///     class C {
   ///       m() => super.foo = 42;
   ///     }
   ///
@@ skipping 36 matching lines @@
   /// non-existing static getter and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo += 42;
   ///
   R visitUnresolvedStaticGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the
   /// non-existing top level getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo += 42;
   ///
   R visitUnresolvedTopLevelGetterCompound(Send node, Element element,
-      MethodElement setter, AssignmentOperator operator, Node rhs, A arg);
+      SetterElement setter, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the static
   /// [getter] and writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo += 42;
   ///
-  R visitUnresolvedStaticSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading from the top level
   /// [getter] and writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo += 42;
   ///
-  R visitUnresolvedTopLevelSetterCompound(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterCompound(Send node, GetterElement getter,
       Element element, AssignmentOperator operator, Node rhs, A arg);
 
   /// Compound assignment of [rhs] with [operator] reading the closurized static
   /// [method] and trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
@@ skipping 13 matching lines @@
   ///     m4() => unresolved.foo += 42;
   ///     m5() => unresolved.Foo.bar += 42;
   ///     m6() => C.unresolved += 42;
   ///     m7() => prefix.C.unresolved += 42;
   ///     m8() => prefix?.unresolved += 42;
   ///     m9() => Unresolved?.foo += 42;
   ///     m10() => unresolved?.foo += 42;
   ///     m11() => unresolved?.Foo?.bar += 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R visitUnresolvedCompound(
-      Send node, Element element, AssignmentOperator operator, Node rhs, A arg);
+  R visitUnresolvedCompound(Send node, ErroneousElement element,
+      AssignmentOperator operator, Node rhs, A arg);
 
   /// Prefix operation of [operator] reading from the non-existing static getter
   /// and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => ++C.foo;
   ///
   R visitUnresolvedStaticGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading from the non-existing top level
   /// getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => ++foo;
   ///
   R visitUnresolvedTopLevelGetterPrefix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading from the static [getter] and
   /// writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => ++C.foo;
   ///
-  R visitUnresolvedStaticSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the top level [getter] and
   /// writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => ++foo;
   ///
-  R visitUnresolvedTopLevelSetterPrefix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPrefix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Prefix operation of [operator] reading the closurized static [method] and
   /// trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
@@ skipping 27 matching lines @@
   ///     m5() => ++unresolved.Foo.bar;
   ///     m6() => ++C.unresolved;
   ///     m7() => ++prefix.C.unresolved;
   ///     m8() => ++prefix?.unresolved;
   ///     m9() => ++Unresolved?.foo;
   ///     m10() => ++unresolved?.foo;
   ///     m11() => ++unresolved?.Foo?.bar;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedPrefix(
-      Send node, Element element, IncDecOperator operator, A arg);
+      Send node, ErroneousElement element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the non-existing static
   /// getter and writing to the static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set foo(_) {}
   ///     }
   ///     m1() => C.foo++;
   ///
   R visitUnresolvedStaticGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the non-existing top level
   /// getter and writing to the top level [setter].
   ///
   /// For instance:
   ///
   ///     set foo(_) {}
   ///     m1() => foo++;
   ///
   R visitUnresolvedTopLevelGetterPostfix(Send node, Element element,
-      MethodElement setter, IncDecOperator operator, A arg);
+      SetterElement setter, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the static [getter] and
   /// writing to the non-existing static setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get foo => 42;
   ///     }
   ///     m1() => C.foo++;
   ///
-  R visitUnresolvedStaticSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedStaticSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading from the top level [getter] and
   /// writing to the non-existing top level setter.
   ///
   /// For instance:
   ///
   ///     get foo => 42;
   ///     m1() => foo++;
   ///
-  R visitUnresolvedTopLevelSetterPostfix(Send node, MethodElement getter,
+  R visitUnresolvedTopLevelSetterPostfix(Send node, GetterElement getter,
       Element element, IncDecOperator operator, A arg);
 
   /// Postfix operation of [operator] reading the closurized static [method] and
   /// trying to invoke the non-existing setter.
   ///
   /// For instance:
   ///
   ///     class C {
   ///       foo() {}
   ///     }
@@ skipping 27 matching lines @@
   ///     m5() => unresolved.Foo.bar++;
   ///     m6() => C.unresolved++;
   ///     m7() => prefix.C.unresolved++;
   ///     m8() => prefix?.unresolved++;
   ///     m9() => Unresolved?.foo++;
   ///     m10() => unresolved?.foo++;
   ///     m11() => unresolved?.Foo?.bar++;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
   R visitUnresolvedPostfix(
-      Send node, Element element, IncDecOperator operator, A arg);
+      Send node, ErroneousElement element, IncDecOperator operator, A arg);
 
   /// Invocation of an undefined unary [operator] on [expression].
   R errorUndefinedUnaryExpression(
       Send node, Operator operator, Node expression, A arg);
 
   /// Invocation of an undefined unary [operator] with operands
   /// [left] and [right].
   R errorUndefinedBinaryExpression(
       Send node, Node left, Operator operator, Node right, A arg);
 
@@ skipping 422 matching lines @@
   /// Apply this visitor to the initializers of [constructor].
   applyInitializers(FunctionExpression constructor, A arg);
 
   /// A declaration of a top level [getter].
   ///
   /// For instance:
   ///
   ///     get m => 42;
   ///
   R visitTopLevelGetterDeclaration(
-      FunctionExpression node, MethodElement getter, Node body, A arg);
+      FunctionExpression node, GetterElement getter, Node body, A arg);
 
   /// A declaration of a top level [setter].
   ///
   /// For instance:
   ///
   ///     set m(a) {}
   ///
   R visitTopLevelSetterDeclaration(FunctionExpression node,
-      MethodElement setter, NodeList parameters, Node body, A arg);
+      SetterElement setter, NodeList parameters, Node body, A arg);
 
   /// A declaration of a top level [function].
   ///
   /// For instance:
   ///
   ///     m(a) {}
   ///
   R visitTopLevelFunctionDeclaration(FunctionExpression node,
       MethodElement function, NodeList parameters, Node body, A arg);
 
   /// A declaration of a static [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static get m => 42;
   ///     }
   ///
   R visitStaticGetterDeclaration(
-      FunctionExpression node, MethodElement getter, Node body, A arg);
+      FunctionExpression node, GetterElement getter, Node body, A arg);
 
   /// A declaration of a static [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static set m(a) {}
   ///     }
   ///
-  R visitStaticSetterDeclaration(FunctionExpression node, MethodElement setter,
+  R visitStaticSetterDeclaration(FunctionExpression node, SetterElement setter,
       NodeList parameters, Node body, A arg);
 
   /// A declaration of a static [function].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       static m(a) {}
   ///     }
   ///
   R visitStaticFunctionDeclaration(FunctionExpression node,
       MethodElement function, NodeList parameters, Node body, A arg);
 
   /// A declaration of an abstract instance [getter].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       get m;
   ///     }
   ///
   R visitAbstractGetterDeclaration(
-      FunctionExpression node, MethodElement getter, A arg);
+      FunctionExpression node, GetterElement getter, A arg);
 
   /// A declaration of an abstract instance [setter].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       set m(a);
   ///     }
   ///
   R visitAbstractSetterDeclaration(FunctionExpression node,
-      MethodElement setter, NodeList parameters, A arg);
+      SetterElement setter, NodeList parameters, A arg);
 
   /// A declaration of an abstract instance [method].
   ///
   /// For instance:
   ///
   ///     abstract class C {
   ///       m(a);
   ///     }
   ///
   R visitAbstractMethodDeclaration(FunctionExpression node,
       MethodElement method, NodeList parameters, A arg);
 
   /// A declaration of an instance [getter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       get m => 42;
   ///     }
   ///
   R visitInstanceGetterDeclaration(
-      FunctionExpression node, MethodElement getter, Node body, A arg);
+      FunctionExpression node, GetterElement getter, Node body, A arg);
 
   /// A declaration of an instance [setter].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       set m(a) {}
   ///     }
   ///
   R visitInstanceSetterDeclaration(FunctionExpression node,
-      MethodElement setter, NodeList parameters, Node body, A arg);
+      SetterElement setter, NodeList parameters, Node body, A arg);
 
   /// A declaration of an instance [method].
   ///
   /// For instance:
   ///
   ///     class C {
   ///       m(a) {}
   ///     }
   ///
   R visitInstanceMethodDeclaration(FunctionExpression node,
@@ skipping 350 matching lines @@
   ///
   /// For instance `this._(42)` in:
   ///
   ///     class C {
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
       Send node, Element element, NodeList arguments, Selector selector, A arg);
 }