Use Name instead of Selector in SemanticSendVisitor

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart2js.semantics_visitor;
 
 /// 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 205 matching lines @@
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandlePrefix(Send node, A arg) {
     return bulkHandleNode(node, "Prefix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   R visitIfNotNullDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitIndexPrefix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
@@ skipping 146 matching lines @@
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePrefix(node, arg);
   }
 
   @override
   R visitTopLevelFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
@@ skipping 225 matching lines @@
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandlePostfix(Send node, A arg) {
     return bulkHandleNode(node, "Postfix expression `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   R visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
@@ skipping 145 matching lines @@
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandlePostfix(node, arg);
   }
 
   @override
   R visitTopLevelFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
@@ skipping 233 matching lines @@
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleCompound(Send node, A arg) {
     return bulkHandleNode(node, "Compound assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
@@ skipping 93 matching lines @@
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return bulkHandleCompound(node, arg);
   }
 
   @override
   R visitTopLevelFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
@@ skipping 299 matching lines @@
       CallStructure callStructure,
       A arg) {
     return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitExpressionInvoke(
       Send node,
       Node expression,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg) {
     return bulkHandleInvoke(node, arg);
   }
 
   @override
   R visitLocalFunctionInvoke(
       Send node,
       LocalFunctionElement function,
       NodeList arguments,
       CallStructure callStructure,
@@ skipping 267 matching lines @@
       Send node,
       ConstantExpression constant,
       A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitDynamicTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       A arg) {
     return bulkHandleGet(node, arg);
@@ skipping 72 matching lines @@
   }
 
   @override
   R visitThisGet(Identifier node, A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitThisPropertyGet(
       Send node,
-      Selector selector,
+      Name name,
       A arg) {
     return bulkHandleGet(node, arg);
   }
 
   @override
   R visitTopLevelFieldGet(
       Send node,
       FieldElement field,
       A arg) {
     return bulkHandleGet(node, arg);
@@ skipping 89 matching lines @@
     implements SemanticSendVisitor<R, A>, BulkHandle<R, A> {
 
   R bulkHandleSet(Send node, A arg) {
     return bulkHandleNode(node, "Assignment `#` unhandled.", arg);
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitLocalVariableSet(
       SendSet node,
       LocalVariableElement variable,
       Node rhs,
@@ skipping 42 matching lines @@
       SendSet node,
       FunctionElement setter,
       Node rhs,
       A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitThisPropertySet(
       SendSet node,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     return bulkHandleSet(node, arg);
   }
 
   @override
   R visitTopLevelFieldSet(
       SendSet node,
       FieldElement field,
       Node rhs,
@@ skipping 2136 matching lines @@
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitIfNotNullDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitIfNotNullDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
@@ skipping 13 matching lines @@
       A arg) {
     apply(receiver, arg);
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitIfNotNullDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitIfNotNullDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(receiver, arg);
     return null;
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     apply(receiver, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitIfNotNullDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     apply(receiver, arg);
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitDynamicTypeLiteralCompound(
       Send node,
@@ skipping 51 matching lines @@
     apply(left, arg);
     apply(right, arg);
     return null;
   }
 
   @override
   R visitExpressionInvoke(
       Send node,
       Node expression,
       NodeList arguments,
-      Selector selector,
+      CallStructure callStructure,
       A arg) {
     apply(expression, arg);
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitIndex(
       Send node,
       Node receiver,
@@ skipping 768 matching lines @@
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitThisPropertyGet(
       Send node,
-      Selector selector,
+      Name name,
       A arg) {
     return null;
   }
 
   @override
   R visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       A arg) {
     apply(arguments, arg);
     return null;
   }
 
   @override
   R visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return null;
   }
 
   @override
   R visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return null;
   }
 
   @override
   R visitThisPropertySet(
       SendSet node,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
     apply(rhs, arg);
     return null;
   }
 
   @override
   R visitTopLevelFieldCompound(
       Send node,
       FieldElement field,
@@ skipping 2751 matching lines @@
 /// `visitThisPropertyY` methods for by delegating calls to `handleDynamicX`
 /// methods, providing `null` as the receiver for the this properties.
 ///
 /// This mixin is useful for the cases where dynamic and this properties are
 /// handled uniformly.
 abstract class BaseImplementationOfDynamicsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   R handleDynamicGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg);
 
   R handleDynamicInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       A arg);
 
   R handleDynamicSet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg);
 
   @override
   R visitDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
-    return handleDynamicGet(node, receiver, selector, arg);
+    return handleDynamicGet(node, receiver, name, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyGet(
       Send node,
       Node receiver,
-      Selector selector,
+      Name name,
       A arg) {
     // TODO(johnniwinther): should these redirect to handleDynamicX?
-    return handleDynamicGet(node, receiver, selector, arg);
+    return handleDynamicGet(node, receiver, name, arg);
   }
 
   @override
   R visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       A arg) {
     return handleDynamicInvoke(node, receiver, arguments, selector, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       A arg) {
     return handleDynamicInvoke(node, receiver, arguments, selector, arg);
   }
 
   @override
   R visitDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
-    return handleDynamicSet(node, receiver, selector, rhs, arg);
+    return handleDynamicSet(node, receiver, name, rhs, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertySet(
       SendSet node,
       Node receiver,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
-    return handleDynamicSet(node, receiver, selector, rhs, arg);
+    return handleDynamicSet(node, receiver, name, rhs, arg);
   }
 
   @override
   R visitThisPropertyGet(
       Send node,
-      Selector selector,
+      Name name,
       A arg) {
-    return handleDynamicGet(node, null, selector, arg);
+    return handleDynamicGet(node, null, name, arg);
   }
 
   @override
   R visitThisPropertyInvoke(
       Send node,
       NodeList arguments,
       Selector selector,
       A arg) {
     return handleDynamicInvoke(node, null, arguments, selector, arg);
   }
 
   @override
   R visitThisPropertySet(
       SendSet node,
-      Selector selector,
+      Name name,
       Node rhs,
       A arg) {
-    return handleDynamicSet(node, null, selector, rhs, arg);
+    return handleDynamicSet(node, null, name, rhs, arg);
   }
 }
 
 /// Mixin that groups all compounds of `visitDynamicPropertyX` and
 /// `visitThisPropertyY` methods for by delegating calls to `handleDynamicX`
 /// methods, providing `null` as the receiver for the this properties.
 ///
 /// This mixin is useful for the cases where dynamic and this properties are
 /// handled uniformly.
 abstract class BaseImplementationOfDynamicCompoundsMixin<R, A>
     implements SemanticSendVisitor<R, A> {
   R handleDynamicCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg);
 
   R handleDynamicPostfixPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg,
       {bool isPrefix});
 
   R handleDynamicIndexPostfixPrefix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg,
       {bool isPrefix});
 
   @override
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompound(
-        node, receiver, operator, rhs, getterSelector, setterSelector, arg);
+        node, receiver, name, operator, rhs, arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompound(
-        node, receiver, operator, rhs, getterSelector, setterSelector, arg);
+        node, receiver, name, operator, rhs, arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: false);
+        node, receiver, name, operator, arg, isPrefix: false);
   }
 
   @override
   R visitIfNotNullDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: false);
+        node, receiver, name, operator, arg, isPrefix: false);
   }
 
   @override
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: true);
+        node, receiver, name, operator, arg, isPrefix: true);
   }
 
   @override
   R visitIfNotNullDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, receiver, operator,
-        getterSelector, setterSelector, arg, isPrefix: true);
+        node, receiver, name, operator, arg, isPrefix: true);
   }
 
   @override
   R visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
-    return handleDynamicCompound(
-        node, null, operator, rhs, getterSelector, setterSelector, arg);
+    return handleDynamicCompound(node, null, name, operator, rhs, arg);
   }
 
   @override
   R visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, null, operator,
-        getterSelector, setterSelector, arg, isPrefix: false);
+        node, null, name, operator, arg, isPrefix: false);
   }
 
   @override
   R visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicPostfixPrefix(
-        node, null, operator,
-        getterSelector, setterSelector, arg, isPrefix: true);
+        node, null, name, operator, arg, isPrefix: true);
   }
 
   @override
   R visitIndexPostfix(
       Send node,
       Node receiver,
       Node index,
       IncDecOperator operator,
       A arg) {
     return handleDynamicIndexPostfixPrefix(
@@ skipping 136 matching lines @@
       SendSet node,
       TypeVariableElement typeVariable,
       CompoundRhs rhs,
       A arg);
 
   /// Handle a dynamic compounds, like `o.foo += 42` or `--o.foo`. [receiver] is
   /// `null` for properties on `this`, like `--this.foo` or `--foo`.
   R handleDynamicCompounds(
       Send node,
       Node receiver,
+      Name name,
       CompoundRhs rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg);
 
   R visitDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new AssignmentCompound(operator, rhs),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   R visitIfNotNullDynamicPropertyCompound(
       Send node,
       Node receiver,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new AssignmentCompound(operator, rhs),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitThisPropertyCompound(
       Send node,
+      Name name,
       AssignmentOperator operator,
       Node rhs,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         null,
+        name,
         new AssignmentCompound(operator, rhs),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       A arg) {
@@ skipping 336 matching lines @@
         node,
         constant,
         new AssignmentCompound(operator, rhs),
         arg);
   }
 
 
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new IncDecCompound(CompoundKind.PREFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   R visitIfNotNullDynamicPropertyPrefix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new IncDecCompound(CompoundKind.PREFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitParameterPrefix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg) {
     return handleLocalCompounds(
@@ skipping 28 matching lines @@
         node,
         function,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg,
         isSetterValid: false);
   }
 
 
   R visitThisPropertyPrefix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         null,
+        name,
         new IncDecCompound(CompoundKind.PREFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitStaticFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
     return handleStaticCompounds(
@@ skipping 216 matching lines @@
         node,
         constant,
         new IncDecCompound(CompoundKind.PREFIX, operator),
         arg);
   }
 
   @override
   R visitDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitIfNotNullDynamicPropertyPostfix(
       Send node,
       Node receiver,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         receiver,
+        name,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitParameterPostfix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg) {
     return handleLocalCompounds(
@@ skipping 28 matching lines @@
         node,
         function,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
         arg,
         isSetterValid: false);
   }
 
 
   R visitThisPropertyPostfix(
       Send node,
+      Name name,
       IncDecOperator operator,
-      Selector getterSelector,
-      Selector setterSelector,
       A arg) {
     return handleDynamicCompounds(
         node,
         null,
+        name,
         new IncDecCompound(CompoundKind.POSTFIX, operator),
-        getterSelector,
-        setterSelector,
         arg);
   }
 
   @override
   R visitStaticFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg) {
     return handleStaticCompounds(
@@ skipping 1737 matching lines @@
       NewExpression node,
       ConstructorElement constructor,
       InterfaceType type,
       NodeList arguments,
       CallStructure callStructure,
       A arg) {
     return handleConstructorInvoke(
         node, constructor, type, arguments, callStructure, arg);
   }
 }