Refactor handling of compounds.

pkg/compiler/lib/src/resolution/send_structure.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.send_structure;
 
 import 'access_semantics.dart';
 import 'operators.dart';
 import 'semantic_visitor.dart';
 import '../dart_types.dart';
@@ skipping 159 matching lines @@
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the function.
             callStructure,
             arg);
       case AccessKind.LOCAL_VARIABLE:
+      case AccessKind.FINAL_LOCAL_VARIABLE:
         return visitor.visitLocalVariableInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the variable.
             callStructure,
             arg);
       case AccessKind.PARAMETER:
+      case AccessKind.FINAL_PARAMETER:
         return visitor.visitParameterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             // TODO(johnniwinther): Store the call selector instead of the
             // selector using the name of the parameter.
             callStructure,
             arg);
       case AccessKind.STATIC_FIELD:
+      case AccessKind.FINAL_STATIC_FIELD:
         return visitor.visitStaticFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.STATIC_METHOD:
         return visitor.visitStaticFunctionInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.STATIC_GETTER:
         return visitor.visitStaticGetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.STATIC_SETTER:
         return visitor.errorStaticSetterInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.TOPLEVEL_FIELD:
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.visitTopLevelFunctionInvoke(
             node,
             semantics.element,
@@ skipping 55 matching lines @@
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyInvoke(
             node,
             node.argumentsNode,
             selector,
             arg);
       case AccessKind.SUPER_FIELD:
+      case AccessKind.SUPER_FINAL_FIELD:
         return visitor.visitSuperFieldInvoke(
             node,
             semantics.element,
             node.argumentsNode,
             callStructure,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperMethodInvoke(
             node,
             semantics.element,
@@ skipping 112 matching lines @@
             node,
             node.receiver,
             selector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
         return visitor.visitLocalFunctionGet(
             node,
             semantics.element,
             arg);
       case AccessKind.LOCAL_VARIABLE:
+      case AccessKind.FINAL_LOCAL_VARIABLE:
         return visitor.visitLocalVariableGet(
             node,
             semantics.element,
             arg);
       case AccessKind.PARAMETER:
+      case AccessKind.FINAL_PARAMETER:
         return visitor.visitParameterGet(
             node,
             semantics.element,
             arg);
       case AccessKind.STATIC_FIELD:
+      case AccessKind.FINAL_STATIC_FIELD:
         return visitor.visitStaticFieldGet(
             node,
             semantics.element,
             arg);
       case AccessKind.STATIC_METHOD:
         return visitor.visitStaticFunctionGet(
             node,
             semantics.element,
             arg);
       case AccessKind.STATIC_GETTER:
         return visitor.visitStaticGetterGet(
             node,
             semantics.element,
             arg);
       case AccessKind.STATIC_SETTER:
         return visitor.errorStaticSetterGet(
             node,
             semantics.element,
             arg);
       case AccessKind.TOPLEVEL_FIELD:
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldGet(
             node,
             semantics.element,
             arg);
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.visitTopLevelFunctionGet(
             node,
             semantics.element,
             arg);
       case AccessKind.TOPLEVEL_GETTER:
@@ skipping 31 matching lines @@
         break;
       case AccessKind.THIS:
         // TODO(johnniwinther): Handle this when `this` is a [Send].
         break;
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyGet(
             node,
             selector,
             arg);
       case AccessKind.SUPER_FIELD:
+      case AccessKind.SUPER_FINAL_FIELD:
         return visitor.visitSuperFieldGet(
             node,
             semantics.element,
             arg);
       case AccessKind.SUPER_METHOD:
         return visitor.visitSuperMethodGet(
             node,
             semantics.element,
             arg);
       case AccessKind.SUPER_GETTER:
@@ skipping 55 matching lines @@
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariableSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_LOCAL_VARIABLE:
+        return visitor.errorFinalLocalVariableSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.PARAMETER:
         return visitor.visitParameterSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_PARAMETER:
+        return visitor.errorFinalParameterSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.STATIC_FIELD:
         return visitor.visitStaticFieldSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_STATIC_FIELD:
+        return visitor.errorFinalStaticFieldSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.STATIC_METHOD:
         return visitor.errorStaticFunctionSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.STATIC_GETTER:
         return visitor.errorStaticGetterSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.STATIC_SETTER:
         return visitor.visitStaticSetterSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
+        return visitor.errorFinalTopLevelFieldSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.TOPLEVEL_METHOD:
         return visitor.errorTopLevelFunctionSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.TOPLEVEL_GETTER:
         return visitor.errorTopLevelGetterSet(
             node,
             semantics.element,
@@ skipping 40 matching lines @@
             node,
             selector,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_FIELD:
         return visitor.visitSuperFieldSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
+      case AccessKind.SUPER_FINAL_FIELD:
+        return visitor.errorFinalSuperFieldSet(
+            node,
+            semantics.element,
+            node.arguments.single,
+            arg);
       case AccessKind.SUPER_METHOD:
         return visitor.errorSuperMethodSet(
             node,
             semantics.element,
             node.arguments.single,
             arg);
       case AccessKind.SUPER_GETTER:
         return visitor.errorSuperGetterSet(
             node,
             semantics.element,
@@ skipping 365 matching lines @@
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitIndexPrefix(
             node,
             node.receiver,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperIndexPrefix(
+            node,
+            semantics.element,
+            node.arguments.single,
+            operator,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperIndexPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
             return visitor.visitUnresolvedSuperGetterIndexPrefix(
                 node,
                 compoundSemantics.getter,
+                compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterIndexPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
@@ skipping 36 matching lines @@
 
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitIndexPostfix(
             node,
             node.receiver,
             node.arguments.single,
             operator,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperIndexPostfix(
+            node,
+            semantics.element,
+            node.arguments.single,
+            operator,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperIndexPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
             return visitor.visitUnresolvedSuperGetterIndexPostfix(
                 node,
                 compoundSemantics.getter,
+                compoundSemantics.setter,
                 node.arguments.single,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterIndexPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.single,
                 operator,
@@ skipping 37 matching lines @@
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyCompound(
             node,
             node.receiver,
             operator,
             node.arguments.single,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
-        return visitor.errorLocalFunctionCompound(
+        return visitor.visitLocalFunctionCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariableCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_LOCAL_VARIABLE:
+        return visitor.visitFinalLocalVariableCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.PARAMETER:
         return visitor.visitParameterCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_PARAMETER:
+        return visitor.visitFinalParameterCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.STATIC_FIELD:
         return visitor.visitStaticFieldCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_STATIC_FIELD:
+        return visitor.visitFinalStaticFieldCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.STATIC_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitStaticMethodCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.STATIC_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.STATIC_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
+        return visitor.visitFinalTopLevelFieldCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.TOPLEVEL_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitTopLevelMethodCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.errorClassTypeLiteralCompound(
+        return visitor.visitClassTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.errorTypedefTypeLiteralCompound(
+        return visitor.visitTypedefTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.errorDynamicTypeLiteralCompound(
+        return visitor.visitDynamicTypeLiteralCompound(
             node,
             semantics.constant,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.errorTypeVariableTypeLiteralCompound(
+        return visitor.visitTypeVariableTypeLiteralCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
         break;
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyCompound(
             node,
             operator,
             node.arguments.single,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.SUPER_FIELD:
         return visitor.visitSuperFieldCompound(
             node,
             semantics.element,
             operator,
             node.arguments.single,
             arg);
+      case AccessKind.SUPER_FINAL_FIELD:
+        return visitor.visitFinalSuperFieldCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.SUPER_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitSuperMethodCompound(
+            node,
+            semantics.element,
+            operator,
+            node.arguments.single,
+            arg);
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
       case AccessKind.UNRESOLVED_SUPER:
-      case AccessKind.UNRESOLVED:
-        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
-        return visitor.errorUnresolvedCompound(
+        return visitor.visitUnresolvedSuperCompound(
             node,
             semantics.element,
             operator,
+            node.arguments.single,
+            arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.visitUnresolvedCompound(
+            node,
+            semantics.element,
+            operator,
             node.arguments.single,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
           case CompoundAccessKind.STATIC_METHOD_SETTER:
             return visitor.visitStaticMethodSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_GETTER:
+            return visitor.visitUnresolvedStaticGetterCompound(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                node.arguments.single,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_SETTER:
+            return visitor.visitUnresolvedStaticSetterCompound(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                node.arguments.single,
+                arg);
           case CompoundAccessKind.TOPLEVEL_GETTER_SETTER:
             return visitor.visitTopLevelGetterSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
           case CompoundAccessKind.TOPLEVEL_METHOD_SETTER:
             return visitor.visitTopLevelMethodSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER:
+            return visitor.visitUnresolvedTopLevelGetterCompound(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                node.arguments.single,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER:
+            return visitor.visitUnresolvedTopLevelSetterCompound(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                node.arguments.single,
+                arg);
           case CompoundAccessKind.SUPER_FIELD_FIELD:
             // TODO(johnniwinther): Handle this.
             break;
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperGetterSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
@@ skipping 16 matching lines @@
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterCompound(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
-          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
-            // TODO(johnniwinther): Handle these separately.
-            return visitor.errorUnresolvedCompound(
+            return visitor.visitUnresolvedSuperGetterCompound(
                 node,
-                semantics.element,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
                 operator,
                 node.arguments.single,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
+            return visitor.visitUnresolvedSuperSetterCompound(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                node.arguments.single,
+                arg);
         }
         break;
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'compound($operator,$semantics)';
 }
 
@@ skipping 19 matching lines @@
   R dispatch(SemanticSendVisitor<R, A> visitor, Send node, A arg) {
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitCompoundIndexSet(
             node,
             node.receiver,
             node.arguments.first,
             operator,
             node.arguments.tail.head,
             arg);
+      case AccessKind.UNRESOLVED_SUPER:
+        return visitor.visitUnresolvedSuperCompoundIndexSet(
+            node,
+            semantics.element,
+            node.arguments.first,
+            operator,
+            node.arguments.tail.head,
+            arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperCompoundIndexSet(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.first,
                 operator,
                 node.arguments.tail.head,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
             return visitor.visitUnresolvedSuperGetterCompoundIndexSet(
                 node,
                 compoundSemantics.getter,
+                compoundSemantics.setter,
                 node.arguments.first,
                 operator,
                 node.arguments.tail.head,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
             return visitor.visitUnresolvedSuperSetterCompoundIndexSet(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 node.arguments.first,
@@ skipping 40 matching lines @@
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyPrefix(
             node,
             node.receiver,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
-        return visitor.errorLocalFunctionPrefix(
+        return visitor.visitLocalFunctionPrefix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariablePrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_LOCAL_VARIABLE:
+        return visitor.visitFinalLocalVariablePrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.PARAMETER:
         return visitor.visitParameterPrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_PARAMETER:
+        return visitor.visitFinalParameterPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_FIELD:
         return visitor.visitStaticFieldPrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_STATIC_FIELD:
+        return visitor.visitFinalStaticFieldPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitStaticMethodPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.STATIC_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldPrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
+        return visitor.visitFinalTopLevelFieldPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.TOPLEVEL_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitTopLevelMethodPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.errorClassTypeLiteralPrefix(
+        return visitor.visitClassTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.errorTypedefTypeLiteralPrefix(
+        return visitor.visitTypedefTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.errorDynamicTypeLiteralPrefix(
+        return visitor.visitDynamicTypeLiteralPrefix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.errorTypeVariableTypeLiteralPrefix(
+        return visitor.visitTypeVariableTypeLiteralPrefix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
         break;
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyPrefix(
             node,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.SUPER_FIELD:
         return visitor.visitSuperFieldPrefix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.SUPER_FINAL_FIELD:
+        return visitor.visitFinalSuperFieldPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.SUPER_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitSuperMethodPrefix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
       case AccessKind.UNRESOLVED_SUPER:
-      case AccessKind.UNRESOLVED:
-        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
-        return visitor.errorUnresolvedPrefix(
+        return visitor.visitUnresolvedSuperPrefix(
             node,
             semantics.element,
             operator,
+            arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.visitUnresolvedPrefix(
+            node,
+            semantics.element,
+            operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.STATIC_METHOD_SETTER:
             return visitor.visitStaticMethodSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_GETTER:
+            return visitor.visitUnresolvedStaticGetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_SETTER:
+            return visitor.visitUnresolvedStaticSetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
+          case CompoundAccessKind.STATIC_METHOD_SETTER:
+            return visitor.visitStaticMethodSetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.TOPLEVEL_GETTER_SETTER:
             return visitor.visitTopLevelGetterSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.TOPLEVEL_METHOD_SETTER:
             return visitor.visitTopLevelMethodSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER:
+            return visitor.visitUnresolvedTopLevelGetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER:
+            return visitor.visitUnresolvedTopLevelSetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.SUPER_FIELD_FIELD:
             return visitor.visitSuperFieldFieldPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperGetterSetterPrefix(
                 node,
@@ skipping 16 matching lines @@
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterPrefix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterPrefix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
-            // TODO(johnniwinther): Handle these directly.
-            return visitor.errorUnresolvedPrefix(
+            return visitor.visitUnresolvedSuperSetterPrefix(
                 node,
-                semantics.element,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'prefix($operator,$semantics)';
 }
@@ skipping 22 matching lines @@
     switch (semantics.kind) {
       case AccessKind.DYNAMIC_PROPERTY:
         return visitor.visitDynamicPropertyPostfix(
             node,
             node.receiver,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.LOCAL_FUNCTION:
-        return visitor.errorLocalFunctionPostfix(
+        return visitor.visitLocalFunctionPostfix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.LOCAL_VARIABLE:
         return visitor.visitLocalVariablePostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_LOCAL_VARIABLE:
+        return visitor.visitFinalLocalVariablePostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.PARAMETER:
         return visitor.visitParameterPostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_PARAMETER:
+        return visitor.visitFinalParameterPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_FIELD:
         return visitor.visitStaticFieldPostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_STATIC_FIELD:
+        return visitor.visitFinalStaticFieldPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitStaticMethodPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.STATIC_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.STATIC_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_FIELD:
         return visitor.visitTopLevelFieldPostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.FINAL_TOPLEVEL_FIELD:
+        return visitor.visitFinalTopLevelFieldPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.TOPLEVEL_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitTopLevelMethodPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.TOPLEVEL_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.TOPLEVEL_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CLASS_TYPE_LITERAL:
-        return visitor.errorClassTypeLiteralPostfix(
+        return visitor.visitClassTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPEDEF_TYPE_LITERAL:
-        return visitor.errorTypedefTypeLiteralPostfix(
+        return visitor.visitTypedefTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.DYNAMIC_TYPE_LITERAL:
-        return visitor.errorDynamicTypeLiteralPostfix(
+        return visitor.visitDynamicTypeLiteralPostfix(
             node,
             semantics.constant,
             operator,
             arg);
       case AccessKind.TYPE_PARAMETER_TYPE_LITERAL:
-        return visitor.errorTypeVariableTypeLiteralPostfix(
+        return visitor.visitTypeVariableTypeLiteralPostfix(
             node,
             semantics.element,
             operator,
             arg);
       case AccessKind.EXPRESSION:
         // This is not a valid case.
         break;
       case AccessKind.THIS:
         // This is not a valid case.
         break;
       case AccessKind.THIS_PROPERTY:
         return visitor.visitThisPropertyPostfix(
             node,
             operator,
             getterSelector,
             setterSelector,
             arg);
       case AccessKind.SUPER_FIELD:
         return visitor.visitSuperFieldPostfix(
             node,
             semantics.element,
             operator,
             arg);
+      case AccessKind.SUPER_FINAL_FIELD:
+        return visitor.visitFinalSuperFieldPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.SUPER_METHOD:
-        // TODO(johnniwinther): Handle this.
-        break;
+        return visitor.visitSuperMethodPostfix(
+            node,
+            semantics.element,
+            operator,
+            arg);
       case AccessKind.SUPER_GETTER:
         // This is not a valid case.
         break;
       case AccessKind.SUPER_SETTER:
         // This is not a valid case.
         break;
       case AccessKind.CONSTANT:
         // TODO(johnniwinther): Should this be a valid case?
         break;
       case AccessKind.UNRESOLVED_SUPER:
-      case AccessKind.UNRESOLVED:
-        // TODO(johnniwinther): Support these through [AccessKind.COMPOUND].
-        return visitor.errorUnresolvedPostfix(
+        return visitor.visitUnresolvedSuperPostfix(
             node,
             semantics.element,
             operator,
+            arg);
+      case AccessKind.UNRESOLVED:
+        return visitor.visitUnresolvedPostfix(
+            node,
+            semantics.element,
+            operator,
             arg);
       case AccessKind.COMPOUND:
         CompoundAccessSemantics compoundSemantics = semantics;
         switch (compoundSemantics.compoundAccessKind) {
           case CompoundAccessKind.STATIC_GETTER_SETTER:
             return visitor.visitStaticGetterSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_GETTER:
+            return visitor.visitUnresolvedStaticGetterPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_STATIC_SETTER:
+            return visitor.visitUnresolvedStaticSetterPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.STATIC_METHOD_SETTER:
             return visitor.visitStaticMethodSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.TOPLEVEL_GETTER_SETTER:
             return visitor.visitTopLevelGetterSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.TOPLEVEL_METHOD_SETTER:
             return visitor.visitTopLevelMethodSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER:
+            return visitor.visitUnresolvedTopLevelGetterPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
+          case CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER:
+            return visitor.visitUnresolvedTopLevelSetterPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.SUPER_FIELD_FIELD:
             return visitor.visitSuperFieldFieldPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_GETTER_SETTER:
             return visitor.visitSuperGetterSetterPostfix(
                 node,
@@ skipping 16 matching lines @@
                 operator,
                 arg);
           case CompoundAccessKind.SUPER_FIELD_SETTER:
             return visitor.visitSuperFieldSetterPostfix(
                 node,
                 compoundSemantics.getter,
                 compoundSemantics.setter,
                 operator,
                 arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_GETTER:
+            return visitor.visitUnresolvedSuperGetterPostfix(
+                node,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
+                operator,
+                arg);
           case CompoundAccessKind.UNRESOLVED_SUPER_SETTER:
-            // TODO(johnniwinther): Handle these directly.
-            return visitor.errorUnresolvedPostfix(
+            return visitor.visitUnresolvedSuperSetterPostfix(
                 node,
-                semantics.element,
+                compoundSemantics.getter,
+                compoundSemantics.setter,
                 operator,
                 arg);
         }
     }
     throw new SpannableAssertionFailure(node,
         "Invalid compound assigment: ${semantics}");
   }
 
   String toString() => 'postfix($operator,$semantics)';
 }
@@ skipping 268 matching lines @@
   final ConstructorElement constructor;
   final Selector selector;
 
   ThisConstructorInvokeStructure(this.constructor, this.selector);
 
   R dispatch(SemanticDeclarationVisitor<R, A> visitor, Send node, A arg) {
     return visitor.visitThisConstructorInvoke(
         node, constructor, node.argumentsNode, selector, arg);
   }
 }