Refactor handling of compounds.

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 '../constants/expressions.dart';
 import '../dart2jslib.dart' show invariant, MessageKind;
 import '../dart_types.dart';
 import '../elements/elements.dart';
@@ skipping 1334 matching lines @@
   ///
   R visitSuperIndexPostfix(
       Send node,
       MethodElement indexFunction,
       MethodElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       A arg);
 
   /// Prefix operation on an index expression `operator super[index]` where
-  /// 'operator []' and maybe also 'operator []=' is unresolved and the
-  /// operation is defined by [operator].
+  /// 'operator []' is unresolved, 'operator []=' is defined by [setter], and
+  /// the operation is defined by [operator].
   ///
   /// For instance:
-  ///     class B {}
+  ///     class B {
+  ///       operator []=(a, b) {}
+  ///     }
   ///     class C extends B {
   ///       m(a) => --super[a];
   ///     }
   ///
   R visitUnresolvedSuperGetterIndexPrefix(
       Send node,
       Element element,
+      MethodElement setter,
       Node index,
       IncDecOperator operator,
       A arg);
 
   /// Postfix operation on an index expression `super[index] operator` where
-  /// 'operator []' and maybe also 'operator []=' is unresolved and the
-  /// operation is defined by [operator].
+  /// 'operator []' is unresolved, 'operator []=' is defined by [setter], and
+  /// the operation is defined by [operator].
   ///
   /// For instance:
-  ///     class B {}
+  ///     class B {
+  ///       operator []=(a, b) {}
+  ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
   R visitUnresolvedSuperGetterIndexPostfix(
       Send 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 {}
+  ///     class B {
+  ///       operator [](_) => 42;
+  ///     }
   ///     class C extends B {
   ///       m(a) => --super[a];
   ///     }
   ///
   R visitUnresolvedSuperSetterIndexPrefix(
       Send 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 {}
+  ///     class B {
+  ///       operator [](_) => 42;
+  ///     }
   ///     class C extends B {
   ///       m(a) => super[a]++;
   ///     }
   ///
   R visitUnresolvedSuperSetterIndexPostfix(
       Send 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].
+  ///
+  /// For instance:
+  ///     class B {
+  ///       operator [](_) => 42;
+  ///     }
+  ///     class C extends B {
+  ///       m(a) => super[a]++;
+  ///     }
+  ///
+  R visitUnresolvedSuperIndexPrefix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg);
+
+  /// Postfix operation on an index expression `super[index] operator` where
+  /// both 'operator []' and 'operator []=' are unresolved and the operation is
+  /// defined by [operator].
+  ///
+  /// For instance:
+  ///     class B {
+  ///       operator [](_) => 42;
+  ///     }
+  ///     class C extends B {
+  ///       m(a) => super[a]++;
+  ///     }
+  ///
+  R visitUnresolvedSuperIndexPostfix(
+      Send node,
+      Element element,
+      Node index,
+      IncDecOperator operator,
+      A arg);
+
   /// Binary expression `left == right`.
   ///
   /// For instance:
   ///     neq(a, b) => a != b;
   ///
   R visitNotEquals(
       Send node,
       Node left,
       Node right,
       A arg);
@@ skipping 251 matching lines @@
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final
   /// [parameter].
   ///
   /// For instance:
   ///     m(final parameter, rhs) => parameter += rhs;
   ///
-  R errorFinalParameterCompound(
+  R visitFinalParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a local
   /// [variable].
   ///
   /// For instance:
@@ skipping 11 matching lines @@
 
   /// Compound assignment expression of [rhs] with [operator] on a final local
   /// [variable].
   ///
   /// For instance:
   ///     m(rhs) {
   ///       final variable = 0;
   ///       variable += rhs;
   ///     }
   ///
-  R errorFinalLocalVariableCompound(
+  R visitFinalLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a local
   /// [function].
   ///
   /// For instance:
   ///     m(rhs) {
   ///       function() {}
   ///       function += rhs;
   ///     }
   ///
-  R errorLocalFunctionCompound(
+  R visitLocalFunctionCompound(
       Send node,
       LocalFunctionElement function,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a static
   /// [field].
   ///
   /// For instance:
@@ skipping 11 matching lines @@
 
   /// Compound assignment expression of [rhs] with [operator] on a final static
   /// [field].
   ///
   /// For instance:
   ///     class C {
   ///       static final field = 0;
   ///       m(rhs) => field += rhs;
   ///     }
   ///
-  R errorFinalStaticFieldCompound(
+  R visitFinalStaticFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// static [getter] and writing to a static [setter].
   ///
   /// For instance:
@@ skipping 17 matching lines @@
   ///
   /// For instance:
   ///     class C {
   ///       static o() {}
   ///       static set o(_) {}
   ///       m(rhs) => o += rhs;
   ///     }
   ///
   R visitStaticMethodSetterCompound(
       Send node,
-      FunctionElement method,
-      FunctionElement setter,
+      MethodElement method,
+      MethodElement 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,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final top
   /// level [field].
   ///
   /// For instance:
   ///     final field = 0;
   ///     m(rhs) => field += rhs;
   ///
-  R errorFinalTopLevelFieldCompound(
+  R visitFinalTopLevelFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// top level [getter] and writing to a top level [setter].
   ///
   /// For instance:
@@ skipping 19 matching lines @@
   ///     m(rhs) => o += rhs;
   ///
   R visitTopLevelMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement 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,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
   /// Compound assignment expression of [rhs] with [operator] on a super
   /// [field].
   ///
   /// For instance:
   ///     class B {
   ///       var field;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field += rhs;
   ///     }
   ///
   R visitSuperFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a final super
   /// [field].
   ///
   /// For instance:
   ///     class B {
-  ///       final field = 0;
+  ///       final field = 42;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field += rhs;
   ///     }
   ///
-  R errorFinalSuperFieldCompound(
+  R visitFinalSuperFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       A arg);
+
+  /// Prefix expression with [operator] on a final super [field].
+  ///
+  /// For instance:
+  ///     class B {
+  ///       final field = 42;
+  ///     }
+  ///     class C extends B {
+  ///       m(rhs) => ++super.field;
+  ///     }
+  ///
+  R visitFinalSuperFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
+  /// Prefix expression with [operator] on an unresolved super property.
+  ///
+  /// For instance:
+  ///     class B {
+  ///     }
+  ///     class C extends B {
+  ///       m(rhs) => ++super.unresolved;
+  ///     }
+  ///
+  R visitUnresolvedSuperPrefix(
+      Send 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);
+
+  /// 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;
+  ///     }
+  ///
+  R visitUnresolvedSuperCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  /// Postfix expression with [operator] on a final super [field].
+  ///
+  /// For instance:
+  ///     class B {
+  ///       final field = 42;
+  ///     }
+  ///     class C extends B {
+  ///       m(rhs) => super.field++;
+  ///     }
+  ///
+  R visitFinalSuperFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
+  /// Compound assignment expression of [rhs] 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 += rhs;
+  ///     }
+  ///
+  R visitSuperFieldFieldCompound(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
 
   /// Compound assignment expression of [rhs] with [operator] reading from a
   /// super [getter] and writing to a super [setter].
   ///
   /// For instance:
   ///     class B {
   ///       get o => 0;
   ///       set o(_) {}
   ///     }
   ///     class C extends B {
@@ skipping 22 matching lines @@
   ///     }
   ///
   R visitSuperMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement 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,
+      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);
+
+  /// 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,
+      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(_) {}
   ///     }
@@ skipping 31 matching lines @@
       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;
   ///
-  R errorClassTypeLiteralCompound(
+  R visitClassTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for typedef [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m(rhs) => F += rhs;
   ///
-  R errorTypedefTypeLiteralCompound(
+  R visitTypedefTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on a type literal
   /// for type variable [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m(rhs) => T += rhs;
   ///     }
   ///
-  R errorTypeVariableTypeLiteralCompound(
+  R visitTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound assignment expression of [rhs] with [operator] on the type
   /// literal for `dynamic`.
   ///
   /// For instance:
   ///     m(rhs) => dynamic += rhs;
   ///
-  R errorDynamicTypeLiteralCompound(
+  R visitDynamicTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on the
   /// index operators of [receiver] whose getter and setter are defined by
   /// [getterSelector] and [setterSelector], respectively.
   ///
@@ skipping 23 matching lines @@
   R visitSuperCompoundIndexSet(
       SendSet node,
       MethodElement getter,
       MethodElement setter,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
   /// Compound index assignment of [rhs] with [operator] to [index] on a super
-  /// super class where the index getter is undefined. The index setter might
-  /// also be undefined.
+  /// super class where the index getter is undefined and the index setter is
+  /// defined by [setter].
   ///
   /// For instance
   ///     class B {
   ///     }
   ///     class C extends B {
   ///       m() => super[1] += 42;
   ///     }
   ///
   R visitUnresolvedSuperGetterCompoundIndexSet(
       Send 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
   /// 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,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
+  /// Compound index assignment of [rhs] with [operator] to [index] on a super
+  /// 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);
+
   /// Prefix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
   ///     m(receiver) => ++receiver.foo;
   ///
   R visitDynamicPropertyPrefix(
       Send node,
       Node receiver,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       A arg);
 
   /// Prefix expression with [operator] on a [parameter].
   ///
   /// For instance:
   ///     m(parameter) => ++parameter;
   ///
   R visitParameterPrefix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg);
 
+  /// Prefix expression with [operator] on a final [parameter].
+  ///
+  /// For instance:
+  ///     m(final parameter) => ++parameter;
+  ///
+  R visitFinalParameterPrefix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg);
+
   /// Prefix expression with [operator] on a local [variable].
   ///
   /// For instance:
   ///     m() {
   ///     var variable;
   ///      ++variable;
   ///     }
   ///
   R visitLocalVariablePrefix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg);
 
+  /// Prefix expression with [operator] on a final local [variable].
+  ///
+  /// For instance:
+  ///     m() {
+  ///     final variable;
+  ///      ++variable;
+  ///     }
+  ///
+  R visitFinalLocalVariablePrefix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg);
+
   /// Prefix expression with [operator] on a local [function].
   ///
   /// For instance:
   ///     m() {
   ///     function() {}
   ///      ++function;
   ///     }
   ///
-  R errorLocalFunctionPrefix(
+  R visitLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       A arg);
 
 
   /// Prefix expression with [operator] of the property on `this` whose getter
   /// and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
@@ skipping 20 matching lines @@
   ///       static var field;
   ///       m() => ++field;
   ///     }
   ///
   R visitStaticFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg);
 
+  /// Prefix expression with [operator] on a final static [field].
+  ///
+  /// For instance:
+  ///     class C {
+  ///       static final field = 42;
+  ///       m() => ++field;
+  ///     }
+  ///
+  R visitFinalStaticFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
   /// Prefix expression with [operator] reading from a static [getter] and
   /// writing to a static [setter].
   ///
   /// For instance:
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => ++o;
   ///     }
   ///
@@ skipping 27 matching lines @@
   /// For instance:
   ///     var field;
   ///     m() => ++field;
   ///
   R visitTopLevelFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg);
 
+  /// Prefix expression with [operator] on a final top level [field].
+  ///
+  /// For instance:
+  ///     final field;
+  ///     m() => ++field;
+  ///
+  R visitFinalTopLevelFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
   /// 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,
@@ skipping 128 matching lines @@
   ///       m() => ++super.o;
   ///     }
   ///
   R visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement 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);
+
+  /// 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);
+
+  /// 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,
+      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 errorClassTypeLiteralPrefix(
+  R visitClassTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => ++F;
   ///
-  R errorTypedefTypeLiteralPrefix(
+  R visitTypedefTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => ++T;
   ///     }
   ///
-  R errorTypeVariableTypeLiteralPrefix(
+  R visitTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => ++dynamic;
   ///
-  R errorDynamicTypeLiteralPrefix(
+  R visitDynamicTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] of the property on [receiver] whose
   /// getter and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
   /// For instance:
@@ skipping 11 matching lines @@
   ///
   /// For instance:
   ///     m(parameter) => parameter++;
   ///
   R visitParameterPostfix(
       Send node,
       ParameterElement parameter,
       IncDecOperator operator,
       A arg);
 
+  /// Postfix expression with [operator] on a final [parameter].
+  ///
+  /// For instance:
+  ///     m(final parameter) => parameter++;
+  ///
+  R visitFinalParameterPostfix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      A arg);
+
   /// Postfix expression with [operator] on a local [variable].
   ///
   /// For instance:
   ///     m() {
-  ///     var variable;
-  ///      variable++;
+  ///       var variable;
+  ///       variable++;
   ///     }
   ///
   R visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       A arg);
 
+  /// Postfix expression with [operator] on a final local [variable].
+  ///
+  /// For instance:
+  ///     m() {
+  ///       final variable;
+  ///       variable++;
+  ///     }
+  ///
+  R visitFinalLocalVariablePostfix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      A arg);
+
   /// Postfix expression with [operator] on a local [function].
   ///
   /// For instance:
   ///     m() {
   ///     function() {}
   ///      function++;
   ///     }
   ///
-  R errorLocalFunctionPostfix(
+  R visitLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       A arg);
 
 
   /// Postfix expression with [operator] of the property on `this` whose getter
   /// and setter are defined by [getterSelector] and [setterSelector],
   /// respectively.
   ///
@@ skipping 20 matching lines @@
   ///       static var field;
   ///       m() => field++;
   ///     }
   ///
   R visitStaticFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg);
 
+  /// Postfix expression with [operator] on a final static [field].
+  ///
+  /// For instance:
+  ///     class C {
+  ///       static final field;
+  ///       m() => field++;
+  ///     }
+  ///
+  R visitFinalStaticFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
   /// Postfix expression with [operator] reading from a static [getter] and
   /// writing to a static [setter].
   ///
   /// For instance:
   ///     class C {
   ///       static get o => 0;
   ///       static set o(_) {}
   ///       m() => o++;
   ///     }
   ///
@@ skipping 27 matching lines @@
   /// For instance:
   ///     var field;
   ///     m() => field++;
   ///
   R visitTopLevelFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       A arg);
 
+  /// Postfix expression with [operator] on a final top level [field].
+  ///
+  /// For instance:
+  ///     final field = 42;
+  ///     m() => field++;
+  ///
+  R visitFinalTopLevelFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      A arg);
+
   /// 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,
@@ skipping 128 matching lines @@
   ///       m() => super.o++;
   ///     }
   ///
   R visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement 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);
+
+  /// 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);
+
+  /// 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,
+      Element element,
+      IncDecOperator operator,
+      A arg);
+
   /// Postfix expression with [operator] on a type literal for a class
   /// [element].
   ///
   /// For instance:
   ///     class C {}
   ///     m() => C++;
   ///
-  R errorClassTypeLiteralPostfix(
+  R visitClassTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a typedef
   /// [element].
   ///
   /// For instance:
   ///     typedef F();
   ///     m() => F++;
   ///
-  R errorTypedefTypeLiteralPostfix(
+  R visitTypedefTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on a type literal for a type variable
   /// [element].
   ///
   /// For instance:
   ///     class C<T> {
   ///       m() => T++;
   ///     }
   ///
-  R errorTypeVariableTypeLiteralPostfix(
+  R visitTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => dynamic++;
   ///
-  R errorDynamicTypeLiteralPostfix(
+  R visitDynamicTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       A arg);
 
   /// Read of the [constant].
   ///
   /// For instance
   ///     const c = c;
   ///     m() => c;
@@ skipping 94 matching lines @@
   ///       m() => super.foo();
   ///     }
   ///
   R visitUnresolvedSuperInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       A arg);
 
-  /// Compound assignment of [rhs] on the unresolved [element].
+  /// Compound assignment of [rhs] with [operator] reading from the
+  /// 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);
+
+  /// 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);
+
+  /// 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,
+      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,
+      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() {}
+  ///     }
+  ///     m1() => C.foo += 42;
+  ///
+  R visitStaticMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      A arg);
+
+  /// Compound assignment of [rhs] where both getter and setter are unresolved.
   ///
   /// For instance
   ///     class C {}
   ///     m1() => unresolved += 42;
   ///     m2() => prefix.unresolved += 42;
   ///     m3() => Unresolved.foo += 42;
   ///     m4() => unresolved.foo += 42;
   ///     m5() => unresolved.Foo.bar += 42;
   ///     m6() => C.unresolved += 42;
   ///     m7() => prefix.C.unresolved += 42;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R errorUnresolvedCompound(
+  R visitUnresolvedCompound(
       Send node,
       Element element,
       AssignmentOperator operator,
       Node rhs,
       A arg);
 
-  /// Prefix operation on the unresolved [element].
+  /// 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);
+
+  /// 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);
+
+  /// 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,
+      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,
+      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() {}
+  ///     }
+  ///     m1() => ++C.foo;
+  ///
+  R visitStaticMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg);
+
+  /// Prefix operation of [operator] reading the closurized top level [method]
+  /// and trying to invoke the non-existing setter.
+  ///
+  /// For instance
+  ///     class C {
+  ///       foo() {}
+  ///     }
+  ///     m1() => ++C.foo;
+  ///
+  R visitTopLevelMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg);
+
+  /// Prefix operation where both getter and setter are unresolved.
   ///
   /// For instance
   ///     class C {}
   ///     m1() => ++unresolved;
   ///     m2() => ++prefix.unresolved;
   ///     m3() => ++Unresolved.foo;
   ///     m4() => ++unresolved.foo;
   ///     m5() => ++unresolved.Foo.bar;
   ///     m6() => ++C.unresolved;
   ///     m7() => ++prefix.C.unresolved;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R errorUnresolvedPrefix(
+  R visitUnresolvedPrefix(
       Send node,
       Element element,
       IncDecOperator operator,
       A arg);
 
-  /// Postfix operation on the unresolved [element].
+  /// 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);
+
+  /// 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);
+
+  /// 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,
+      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,
+      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() {}
+  ///     }
+  ///     m1() => C.foo++;
+  ///
+  R visitStaticMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg);
+
+  /// Postfix operation of [operator] reading the closurized top level [method]
+  /// and trying to invoke the non-existing setter.
+  ///
+  /// For instance
+  ///     class C {
+  ///       foo() {}
+  ///     }
+  ///     m1() => C.foo++;
+  ///
+  R visitTopLevelMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      A arg);
+
+  /// Postfix operation where both getter and setter are unresolved.
   ///
   /// For instance
   ///     class C {}
   ///     m1() => unresolved++;
   ///     m2() => prefix.unresolved++;
   ///     m3() => Unresolved.foo++;
   ///     m4() => unresolved.foo++;
   ///     m5() => unresolved.Foo.bar++;
   ///     m6() => C.unresolved++;
   ///     m7() => prefix.C.unresolved++;
   ///
   // TODO(johnniwinther): Split the cases in which a prefix is resolved.
-  R errorUnresolvedPostfix(
+  R visitUnresolvedPostfix(
       Send node,
       Element element,
       IncDecOperator operator,
       A arg);
 
   /// Invocation of an undefined unary [operator] on [expression].
   R errorUndefinedUnaryExpression(
       Send node,
       Operator operator,
       Node expression,
@@ skipping 733 matching lines @@
   ///       C() : this._(42);
   ///     }
   ///
   R errorUnresolvedThisConstructorInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       A arg);
 }