Revert "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 []' is unresolved, 'operator []=' is defined by [setter], and
-  /// the operation is defined by [operator].
+  /// 'operator []' and maybe also 'operator []=' is unresolved and the
+  /// operation is defined by [operator].
   ///
   /// For instance:
-  ///     class B {
-  ///       operator []=(a, b) {}
-  ///     }
+  ///     class 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 []' is unresolved, 'operator []=' is defined by [setter], and
-  /// the operation is defined by [operator].
+  /// 'operator []' and maybe also 'operator []=' is unresolved and the
+  /// operation is defined by [operator].
   ///
   /// For instance:
-  ///     class B {
-  ///       operator []=(a, b) {}
-  ///     }
+  ///     class 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 {
-  ///       operator [](_) => 42;
-  ///     }
+  ///     class B {}
   ///     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 {
-  ///       operator [](_) => 42;
-  ///     }
+  ///     class B {}
   ///     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 visitFinalParameterCompound(
+  R errorFinalParameterCompound(
       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 visitFinalLocalVariableCompound(
+  R errorFinalLocalVariableCompound(
       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 visitLocalFunctionCompound(
+  R errorLocalFunctionCompound(
       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 visitFinalStaticFieldCompound(
+  R errorFinalStaticFieldCompound(
       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,
-      MethodElement method,
-      MethodElement setter,
+      FunctionElement method,
+      FunctionElement 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 visitFinalTopLevelFieldCompound(
+  R errorFinalTopLevelFieldCompound(
       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 = 42;
+  ///       final field = 0;
   ///     }
   ///     class C extends B {
   ///       m(rhs) => super.field += rhs;
   ///     }
   ///
-  R visitFinalSuperFieldCompound(
+  R errorFinalSuperFieldCompound(
       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 visitClassTypeLiteralCompound(
+  R errorClassTypeLiteralCompound(
       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 visitTypedefTypeLiteralCompound(
+  R errorTypedefTypeLiteralCompound(
       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 visitTypeVariableTypeLiteralCompound(
+  R errorTypeVariableTypeLiteralCompound(
       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 visitDynamicTypeLiteralCompound(
+  R errorDynamicTypeLiteralCompound(
       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 and the index setter is
-  /// defined by [setter].
+  /// super class where the index getter is undefined. The index setter might
+  /// also be undefined.
   ///
   /// 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 visitLocalFunctionPrefix(
+  R errorLocalFunctionPrefix(
       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 visitClassTypeLiteralPrefix(
+  R errorClassTypeLiteralPrefix(
       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 visitTypedefTypeLiteralPrefix(
+  R errorTypedefTypeLiteralPrefix(
       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 visitTypeVariableTypeLiteralPrefix(
+  R errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Prefix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => ++dynamic;
   ///
-  R visitDynamicTypeLiteralPrefix(
+  R errorDynamicTypeLiteralPrefix(
       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 visitLocalFunctionPostfix(
+  R errorLocalFunctionPostfix(
       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 visitClassTypeLiteralPostfix(
+  R errorClassTypeLiteralPostfix(
       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 visitTypedefTypeLiteralPostfix(
+  R errorTypedefTypeLiteralPostfix(
       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 visitTypeVariableTypeLiteralPostfix(
+  R errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       A arg);
 
   /// Postfix expression with [operator] on the type literal for `dynamic`.
   ///
   /// For instance:
   ///     m() => dynamic++;
   ///
-  R visitDynamicTypeLiteralPostfix(
+  R errorDynamicTypeLiteralPostfix(
       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] 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.
+  /// Compound assignment of [rhs] on the unresolved [element].
   ///
   /// 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 visitUnresolvedCompound(
+  R errorUnresolvedCompound(
       Send node,
       Element 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);
-
-  /// 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.
+  /// Prefix operation on the unresolved [element].
   ///
   /// 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 visitUnresolvedPrefix(
+  R errorUnresolvedPrefix(
       Send node,
       Element 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);
-
-  /// 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.
+  /// Postfix operation on the unresolved [element].
   ///
   /// 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 visitUnresolvedPostfix(
+  R errorUnresolvedPostfix(
       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);
 }