Refactor handling of compounds.

tests/compiler/dart2js/semantic_visitor_test.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_test;
 
 import 'dart:async';
+import 'dart:mirrors';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
 import 'package:compiler/src/dart_types.dart';
 import 'package:compiler/src/dart2jslib.dart';
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/resolution/resolution.dart';
 import 'package:compiler/src/resolution/semantic_visitor.dart';
 import 'package:compiler/src/resolution/operators.dart';
 import 'package:compiler/src/tree/tree.dart';
@@ skipping 1488 matching lines @@
             constant: 'dynamic',
             operator: '+=', rhs: '42')),*/
     const Test(
         '''
         m(a) => a += 42;
         ''',
         const Visit(VisitKind.VISIT_PARAMETER_COMPOUND,
             element: 'parameter(m#a)', operator: '+=', rhs: '42')),
     const Test(
         '''
+        m(final a) => a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_PARAMETER_COMPOUND,
+            element: 'parameter(m#a)', operator: '+=', rhs: '42')),
+    const Test(
+        '''
         m() {
           var a;
           a += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_COMPOUND,
             element: 'variable(m#a)', operator: '+=', rhs: '42')),
     const Test(
         '''
+        m() {
+          final a;
+          a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_COMPOUND,
+            element: 'variable(m#a)', operator: '+=', rhs: '42')),
+    const Test(
+        '''
+        m() {
+          a() {}
+          a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_LOCAL_FUNCTION_COMPOUND,
+            element: 'function(m#a)', operator: '+=', rhs: '42')),
+    const Test(
+        '''
         var a;
         m() => a += 42;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_COMPOUND,
             element: 'field(a)', operator: '+=', rhs: '42')),
     const Test(
         '''
         get a => 0;
         set a(_) {}
         m() => a += 42;
@@ skipping 162 matching lines @@
         }
         class C extends B {
           m() => super.a += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_COMPOUND,
             element: 'field(B#a)', operator: '+=', rhs: '42')),
     const Test.clazz(
         '''
         class B {
+          final a = 0;
+        }
+        class C extends B {
+          m() => super.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_COMPOUND,
+            element: 'field(B#a)', operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
           get a => 0;
           set a (_) {}
         }
         class C extends B {
           m() => super.a += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_COMPOUND,
             getter: 'getter(B#a)', setter: 'setter(B#a)',
             operator: '+=', rhs: '42')),
@@ skipping 54 matching lines @@
           final a;
         }
 
         class C extends B {
           m() => super.a += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_COMPOUND,
             getter: 'field(B#a)', setter: 'field(A#a)',
             operator: '+=', rhs: '42')),*/
+    const Test.clazz(
+        '''
+        class B {
+          a() {}
+        }
+        class C extends B {
+          m() => super.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_METHOD_COMPOUND,
+            element: 'function(B#a)',
+            operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => super.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_COMPOUND,
+            operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+          set a(_) {}
+        }
+        class C extends B {
+          m() => super.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND,
+            setter: 'setter(B#a)', operator: '+=', rhs: '42')),
+    const Test.clazz(
+        '''
+        class B {
+          get a => 42;
+        }
+        class C extends B {
+          m() => super.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND,
+            getter: 'getter(B#a)', operator: '+=', rhs: '42')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static set a(var value) { }
+          m() => a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_COMPOUND,
+            setter: 'setter(C#a)', operator: '+=', rhs: '42')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static get a => 42;
+          m() => C.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_COMPOUND,
+            getter: 'getter(C#a)', operator: '+=', rhs: '42')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static final a = 42;
+          m() => C.a += 42;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_COMPOUND,
+            element: 'field(C#a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        class C {
+          static a(var value) { }
+        }
+        m() => C.a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_STATIC_METHOD_COMPOUND,
+            element: 'function(C#a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        set a(var value) { }
+        m() => a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_COMPOUND,
+            setter: 'setter(a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        get a => 42;
+        m() => a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_COMPOUND,
+            getter: 'getter(a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        a(var value) { }
+        m() => a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_COMPOUND,
+            element: 'function(a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        final a = 42;
+        m() => a += 42;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_COMPOUND,
+            element: 'field(a)', operator: '+=', rhs: '42')),
+
+    const Test(
+        '''
+        m() => unresolved += 42;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_COMPOUND,
+            operator: '+=', rhs: '42')),
   ],
   'Compound index assignment': const [
     // Compound index assignment
     const Test(
         '''
         m() => 0[1] += 42;
         ''',
         const Visit(VisitKind.VISIT_COMPOUND_INDEX_SET,
             receiver: '0', index: '1', operator: '+=', rhs: '42')),
     const Test.clazz(
@@ skipping 58 matching lines @@
               element: 'parameter(m#a)')
         ]),
     const Test(
         '''
         m(a) => ++a;
         ''',
         const Visit(VisitKind.VISIT_PARAMETER_PREFIX,
             element: 'parameter(m#a)', operator: '++')),
     const Test(
         '''
+        m(final a) => ++a;
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_PARAMETER_PREFIX,
+            element: 'parameter(m#a)', operator: '++')),
+    const Test(
+        '''
         m() {
           var a;
           --a;
         }
         ''',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_PREFIX,
             element: 'variable(m#a)', operator: '--')),
     const Test(
         '''
+        m() {
+          final a = 42;
+          --a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_PREFIX,
+            element: 'variable(m#a)', operator: '--')),
+    const Test(
+        '''
+        m() {
+          a() {}
+          --a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_LOCAL_FUNCTION_PREFIX,
+            element: 'function(m#a)', operator: '--')),
+    const Test(
+        '''
         var a;
         m() => ++a;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_PREFIX,
             element: 'field(a)', operator: '++')),
     const Test(
         '''
         get a => 0;
         set a(_) {}
         m() => --a;
@@ skipping 114 matching lines @@
         }
         class C extends B {
           m() => --super.a;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_PREFIX,
             element: 'field(B#a)', operator: '--')),
     const Test.clazz(
         '''
         class B {
+          final a = 0;
+        }
+        class C extends B {
+          m() => --super.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_PREFIX,
+            element: 'field(B#a)', operator: '--')),
+    const Test.clazz(
+        '''
+        class B {
           get a => 0;
           set a (_) {}
         }
         class C extends B {
           m() => --super.a;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_PREFIX,
             getter: 'getter(B#a)', setter: 'setter(B#a)',
             operator: '--')),
@@ skipping 37 matching lines @@
           set a(_) {}
         }
 
         class C extends B {
           m() => ++super.a;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_PREFIX,
             getter: 'field(A#a)', setter: 'setter(B#a)',
             operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          a() {}
+        }
+        class C extends B {
+          m() => ++super.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_METHOD_PREFIX,
+            element: 'function(B#a)',
+            operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => ++super.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_PREFIX,
+            operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          set a(_) {}
+        }
+        class C extends B {
+          m() => ++super.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_PREFIX,
+            setter: 'setter(B#a)', operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          get a => 42;
+        }
+        class C extends B {
+          m() => ++super.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_PREFIX,
+            getter: 'getter(B#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static set a(var value) { }
+          m() => ++a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_PREFIX,
+            setter: 'setter(C#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static get a => 42;
+          m() => ++C.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_PREFIX,
+            getter: 'getter(C#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static final a = 42;
+          m() => ++C.a;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_PREFIX,
+            element: 'field(C#a)', operator: '++')),
+
+    const Test(
+        '''
+        class C {
+          static a(var value) { }
+        }
+        m() => ++C.a;
+        ''',
+        const Visit(VisitKind.VISIT_STATIC_METHOD_PREFIX,
+            element: 'function(C#a)', operator: '++')),
+
+    const Test(
+        '''
+        set a(var value) { }
+        m() => ++a;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_PREFIX,
+            setter: 'setter(a)', operator: '++')),
+
+    const Test(
+        '''
+        get a => 42;
+        m() => ++a;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_PREFIX,
+            getter: 'getter(a)', operator: '++')),
+
+    const Test(
+        '''
+        a(var value) { }
+        m() => ++a;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_PREFIX,
+            element: 'function(a)', operator: '++')),
+
+    const Test(
+        '''
+        final a = 42;
+        m() => ++a;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_PREFIX,
+            element: 'field(a)', operator: '++')),
+
+    const Test(
+        '''
+        m() => ++unresolved;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_PREFIX,
+            operator: '++')),
   ],
   'Postfix expression': const [
     // Postfix expression
     const Test(
         '''
         m(a) => a.b--;
         ''',
         const [
           const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_POSTFIX,
               receiver: 'a', operator: '--',
               getter: 'Selector(getter, b, arity=0)',
               setter: 'Selector(setter, b, arity=1)'),
           const Visit(VisitKind.VISIT_PARAMETER_GET,
               element: 'parameter(m#a)')
         ]),
     const Test(
         '''
         m(a) => a++;
         ''',
         const Visit(VisitKind.VISIT_PARAMETER_POSTFIX,
             element: 'parameter(m#a)', operator: '++')),
     const Test(
         '''
+        m(final a) => a++;
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_PARAMETER_POSTFIX,
+            element: 'parameter(m#a)', operator: '++')),
+    const Test(
+        '''
         m() {
           var a;
           a--;
         }
         ''',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_POSTFIX,
             element: 'variable(m#a)', operator: '--')),
     const Test(
         '''
+        m() {
+          final a = 42;
+          a--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_POSTFIX,
+            element: 'variable(m#a)', operator: '--')),
+    const Test(
+        '''
+        m() {
+          a() {}
+          a--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_LOCAL_FUNCTION_POSTFIX,
+            element: 'function(m#a)', operator: '--')),
+    const Test(
+        '''
         var a;
         m() => a++;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_POSTFIX,
             element: 'field(a)', operator: '++')),
     const Test(
         '''
         get a => 0;
         set a(_) {}
         m() => a--;
@@ skipping 114 matching lines @@
         }
         class C extends B {
           m() => super.a--;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_POSTFIX,
             element: 'field(B#a)', operator: '--')),
     const Test.clazz(
         '''
         class B {
+          final a = 0;
+        }
+        class C extends B {
+          m() => super.a--;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_POSTFIX,
+            element: 'field(B#a)', operator: '--')),
+    const Test.clazz(
+        '''
+        class B {
           get a => 0;
           set a (_) {}
         }
         class C extends B {
           m() => super.a--;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_GETTER_SETTER_POSTFIX,
             getter: 'getter(B#a)', setter: 'setter(B#a)',
             operator: '--')),
@@ skipping 37 matching lines @@
           set a(_) {}
         }
 
         class C extends B {
           m() => super.a++;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_POSTFIX,
             getter: 'field(A#a)', setter: 'setter(B#a)',
             operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          a() {}
+        }
+        class C extends B {
+          m() => super.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_SUPER_METHOD_POSTFIX,
+            element: 'function(B#a)',
+            operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+        }
+        class C extends B {
+          m() => super.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_POSTFIX,
+            operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          set a(_) {}
+        }
+        class C extends B {
+          m() => super.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_POSTFIX,
+            setter: 'setter(B#a)', operator: '++')),
+    const Test.clazz(
+        '''
+        class B {
+          get a => 42;
+        }
+        class C extends B {
+          m() => super.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_POSTFIX,
+            getter: 'getter(B#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static set a(var value) { }
+          m() => a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_POSTFIX,
+            setter: 'setter(C#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static get a => 42;
+          m() => C.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_POSTFIX,
+            getter: 'getter(C#a)', operator: '++')),
+
+    const Test.clazz(
+        '''
+        class C {
+          static final a = 42;
+          m() => C.a++;
+        }
+        ''',
+        const Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_POSTFIX,
+            element: 'field(C#a)', operator: '++')),
 
     const Test(
         '''
-        set topLevel(var value) { }
-        m() => topLevel++;
+        class C {
+          static a(var value) { }
+        }
+        m() => C.a++;
         ''',
-        const Visit(VisitKind.ERROR_UNRESOLVED_POSTFIX,
+        const Visit(VisitKind.VISIT_STATIC_METHOD_POSTFIX,
+            element: 'function(C#a)', operator: '++')),
+
+    const Test(
+        '''
+        set a(var value) { }
+        m() => a++;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_POSTFIX,
+            setter: 'setter(a)', operator: '++')),
+
+    const Test(
+        '''
+        get a => 42;
+        m() => a++;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_POSTFIX,
+            getter: 'getter(a)', operator: '++')),
+
+    const Test(
+        '''
+        a(var value) { }
+        m() => a++;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_POSTFIX,
+            element: 'function(a)', operator: '++')),
+
+    const Test(
+        '''
+        final a = 42;
+        m() => a++;
+        ''',
+        const Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_POSTFIX,
+            element: 'field(a)', operator: '++')),
+
+    const Test(
+        '''
+        m() => unresolved++;
+        ''',
+        const Visit(VisitKind.VISIT_UNRESOLVED_POSTFIX,
             operator: '++')),
   ],
   'Constructor invocations': const [
     const Test(
         '''
         class Class {
           const Class(a, b);
         }
         m() => const Class(true, 42);
         ''',
@@ skipping 975 matching lines @@
         const m = 42;
         ''',
         const [
           const Visit(VisitKind.VISIT_TOP_LEVEL_CONSTANT_DECL,
                 element: 'field(m)',
                 constant: 42),
         ]),
   ],
 };
 
+const List<VisitKind> UNTESTABLE_KINDS = const <VisitKind>[
+  VisitKind.VISIT_STATIC_METHOD_SETTER_COMPOUND,
+  VisitKind.VISIT_STATIC_METHOD_SETTER_PREFIX,
+  VisitKind.VISIT_STATIC_METHOD_SETTER_POSTFIX,
+  VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_COMPOUND,
+  VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_PREFIX,
+  VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_POSTFIX,
+  VisitKind.VISIT_SUPER_FIELD_FIELD_COMPOUND,
+  VisitKind.VISIT_SUPER_FIELD_FIELD_PREFIX,
+  VisitKind.VISIT_SUPER_FIELD_FIELD_POSTFIX,
+  VisitKind.VISIT_SUPER_METHOD_SETTER_COMPOUND,
+  VisitKind.VISIT_SUPER_METHOD_SETTER_PREFIX,
+  VisitKind.VISIT_SUPER_METHOD_SETTER_POSTFIX,
+  VisitKind.VISIT_SUPER_NOT_EQUALS,
+  VisitKind.VISIT_CLASS_TYPE_LITERAL_SET,
+  VisitKind.VISIT_CLASS_TYPE_LITERAL_COMPOUND,
+  VisitKind.VISIT_CLASS_TYPE_LITERAL_PREFIX,
+  VisitKind.VISIT_CLASS_TYPE_LITERAL_POSTFIX,
+  VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_SET,
+  VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
+  VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
+  VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
+  VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_SET,
+  VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+  VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+  VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+  VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_SET,
+  VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
+  VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
+  VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
+  VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
+];
+
 main(List<String> arguments) {
+  Set<VisitKind> kinds = new Set<VisitKind>.from(VisitKind.values);
   asyncTest(() => Future.forEach([
     () {
       return test(
+          kinds,
           arguments,
           SEND_TESTS,
           (elements) => new SemanticSendTestVisitor(elements));
     },
     () {
       return test(
+          kinds,
           arguments,
           DECL_TESTS,
           (elements) => new SemanticDeclarationTestVisitor(elements));
     },
+    () {
+      Set<VisitKind> unvisitedKindSet =
+          kinds.toSet()..removeAll(UNTESTABLE_KINDS);
+      List<VisitKind> unvisitedKindList = unvisitedKindSet.toList();
+      unvisitedKindList..sort((a, b) => a.index.compareTo(b.index));
+
+      Expect.isTrue(unvisitedKindList.isEmpty,
+          "Untested visit kinds:\n  ${unvisitedKindList.join(',\n  ')},\n");
+
+      Set<VisitKind> testedUntestableKinds =
+          UNTESTABLE_KINDS.toSet()..removeAll(kinds);
+      Expect.isTrue(testedUntestableKinds.isEmpty,
+          "Tested untestable visit kinds (remove from UNTESTABLE_KINDS):\n  "
+          "${testedUntestableKinds.join(',\n  ')},\n");
+    },
+    () {
+      ClassMirror mirror1 = reflectType(SemanticSendTestVisitor);
+      Set<Symbol> symbols1 = mirror1.declarations.keys.toSet();
+      ClassMirror mirror2 = reflectType(SemanticSendVisitor);
+      Set<Symbol> symbols2 =
+          mirror2.declarations.values
+              .where((m) => m is MethodMirror &&
+                            !m.isConstructor &&
+                            m.simpleName != #apply)
+              .map((m) => m.simpleName).toSet();
+      symbols2.removeAll(symbols1);
+      print("Untested visit methods:\n  ${symbols2.join(',\n  ')},\n");
+    }
   ], (f) => f()));
 }
 
-Future test(List<String> arguments,
+Future test(Set<VisitKind> unvisitedKinds,
+            List<String> arguments,
             Map<String, List<Test>> TESTS,
             SemanticTestVisitor createVisitor(TreeElements elements)) {
   Map<String, String> sourceFiles = {};
   Map<String, Test> testMap = {};
   StringBuffer mainSource = new StringBuffer();
   int index = 0;
   TESTS.forEach((String group, List<Test> tests) {
     if (arguments.isNotEmpty && !arguments.contains(group)) return;
 
     tests.forEach((Test test) {
@@ skipping 48 matching lines @@
             //print(resolvedAst.node.toDebugString());
             resolvedAst.node.accept(visitor);
           });
         } catch (e, s) {
           Expect.fail("$e:\n$s\nIn test:\n"
                       "${library.compilationUnit.script.text}");
         }
         Expect.listEquals(expectedVisits, visitor.visits,
             "In test:\n"
             "${library.compilationUnit.script.text}");
+        unvisitedKinds.removeAll(visitor.visits.map((visit) => visit.method));
       }
       if (element.isAbstractField) {
         AbstractFieldElement abstractFieldElement = element;
         if (abstractFieldElement.getter != null) {
           testAstElement(abstractFieldElement.getter);
         } else if (abstractFieldElement.setter != null) {
           testAstElement(abstractFieldElement.setter);
         }
       } else {
         testAstElement(element);
@@ skipping 32 matching lines @@
   @override
   visitAssert(
       Send node,
       Node expression,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_ASSERT, expression: expression));
     apply(expression, arg);
   }
 
   @override
-  errorInvalidAssert(
-      Send node,
-      NodeList arguments,
-      arg) {
-    // TODO: implement errorAssert
-  }
-
-  @override
   visitBinary(
       Send node,
       Node left,
       BinaryOperator operator,
       Node right,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_BINARY,
         left: left, operator: operator, right: right));
     apply(left, arg);
     apply(right, arg);
@@ skipping 404 matching lines @@
       Send node,
       Element element,
       BinaryOperator operator,
       Node argument,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_BINARY,
         operator: operator, right: argument));
     apply(argument, arg);
   }
 
-
   @override
   visitSuperIndex(
       Send node,
       FunctionElement function,
       Node index,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX,
             element: function, index: index));
     apply(index, arg);
   }
@@ skipping 423 matching lines @@
       Node index,
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX_SET,
         element: function, index: index, rhs: rhs));
     apply(index, arg);
     apply(rhs, arg);
   }
 
   @override
-  errorFinalLocalVariableSet(
-      SendSet node,
-      LocalVariableElement variable,
-      Node rhs,
-      arg) {
-    // TODO: implement errorFinalLocalVariableSet
-  }
-
-  @override
-  errorFinalParameterSet(
-      SendSet node,
-      ParameterElement parameter,
-      Node rhs,
-      arg) {
-    // TODO: implement errorFinalParameterSet
-  }
-
-  @override
-  errorFinalStaticFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      arg) {
-    // TODO: implement errorFinalStaticFieldSet
-  }
-
-  @override
-  errorFinalSuperFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      arg) {
-    // TODO: implement errorFinalSuperFieldSet
-  }
-
-  @override
-  errorFinalTopLevelFieldSet(
-      SendSet node,
-      FieldElement field,
-      Node rhs,
-      arg) {
-    // TODO: implement errorFinalTopLevelFieldSet
-  }
-
-  @override
-  errorLocalFunctionSet(
-      SendSet node,
-      LocalFunctionElement function,
-      Node rhs,
-      arg) {
-    // TODO: implement errorLocalFunctionSet
-  }
-
-  @override
-  errorStaticFunctionSet(
-      Send node,
-      MethodElement function,
-      Node rhs,
-      arg) {
-    // TODO: implement errorStaticFunctionSet
-  }
-
-  @override
-  errorStaticGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      arg) {
-    // TODO: implement errorStaticGetterSet
-  }
-
-  @override
-  errorStaticSetterGet(
-      Send node,
-      FunctionElement setter,
-      arg) {
-    // TODO: implement errorStaticSetterGet
-  }
-
-  @override
-  errorStaticSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      arg) {
-    // TODO: implement errorStaticSetterInvoke
-  }
-
-  @override
-  errorSuperGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      arg) {
-    // TODO: implement errorSuperGetterSet
-  }
-
-  @override
-  errorSuperMethodSet(
-      Send node,
-      MethodElement method,
-      Node rhs,
-      arg) {
-    // TODO: implement errorSuperMethodSet
-  }
-
-  @override
-  errorSuperSetterGet(
-      Send node,
-      FunctionElement setter,
-      arg) {
-    // TODO: implement errorSuperSetterGet
-  }
-
-  @override
-  errorSuperSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      arg) {
-    // TODO: implement errorSuperSetterInvoke
-  }
-
-  @override
-  errorTopLevelFunctionSet(
-      Send node,
-      MethodElement function,
-      Node rhs,
-      arg) {
-    // TODO: implement errorTopLevelFunctionSet
-  }
-
-  @override
-  errorTopLevelGetterSet(
-      SendSet node,
-      FunctionElement getter,
-      Node rhs,
-      arg) {
-    // TODO: implement errorTopLevelGetterSet
-  }
-
-  @override
-  errorTopLevelSetterGet(
-      Send node,
-      FunctionElement setter,
-      arg) {
-    // TODO: implement errorTopLevelSetterGet
-  }
-
-  @override
-  errorTopLevelSetterInvoke(
-      Send node,
-      FunctionElement setter,
-      NodeList arguments,
-      CallStructure callStructure,
-      arg) {
-    // TODO: implement errorTopLevelSetterInvoke
-  }
-
-  @override
   visitDynamicPropertyCompound(
       Send node,
       Node receiver,
       AssignmentOperator operator,
       Node rhs,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_COMPOUND,
         receiver: receiver, operator: operator, rhs: rhs,
         getter: getterSelector, setter: setterSelector));
     apply(receiver, arg);
     apply(rhs, arg);
   }
 
   @override
-  errorFinalLocalVariableCompound(
+  visitFinalLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorFinalLocalVariableCompound
+    visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_COMPOUND,
+        element: variable, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
-  errorFinalParameterCompound(
+  visitFinalLocalVariablePrefix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_PREFIX,
+        element: variable, operator: operator));
+  }
+
+  @override
+  visitFinalLocalVariablePostfix(
+      Send node,
+      LocalVariableElement variable,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_POSTFIX,
+        element: variable, operator: operator));
+  }
+
+  @override
+  visitFinalParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorFinalParameterCompound
+    visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_COMPOUND,
+        element: parameter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
-  errorFinalStaticFieldCompound(
+  visitFinalParameterPrefix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_PREFIX,
+        element: parameter, operator: operator));
+  }
+
+  @override
+  visitFinalParameterPostfix(
+      Send node,
+      ParameterElement parameter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_POSTFIX,
+        element: parameter, operator: operator));
+  }
+
+  @override
+  visitStaticFinalFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorFinalStaticFieldCompound
+    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_COMPOUND,
+        element: field, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
-  errorFinalSuperFieldCompound(
+  visitStaticFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_POSTFIX,
+        element: field, operator: operator));
+  }
+
+  @override
+  visitStaticFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_PREFIX,
+        element: field, operator: operator));
+  }
+
+  @override
+  visitSuperFinalFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorFinalSuperFieldCompound
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_COMPOUND,
+        element: field, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
-  errorFinalTopLevelFieldCompound(
+  visitTopLevelFinalFieldCompound(
       Send node,
       FieldElement field,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorFinalTopLevelFieldCompound
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_COMPOUND,
+        element: field, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
-  errorLocalFunctionCompound(
+  visitTopLevelFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_POSTFIX,
+        element: field, operator: operator));
+  }
+
+  @override
+  visitTopLevelFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_PREFIX,
+        element: field, operator: operator));
+  }
+
+  @override
+  visitLocalFunctionCompound(
       Send node,
       LocalFunctionElement function,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorLocalFunctionCompound
+    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_COMPOUND,
+        element: function, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
   visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_COMPOUND,
@@ skipping 148 matching lines @@
   }
 
   @override
   visitSuperMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement visitSuperMethodSetterCompound
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_COMPOUND,
+        getter: method, setter: setter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
+  visitSuperMethodCompound(
+      Send node,
+      FunctionElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_COMPOUND,
+        element: method, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitSuperMethodPrefix(
+      Send node,
+      FunctionElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_PREFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitSuperMethodPostfix(
+      Send node,
+      FunctionElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_POSTFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperCompound(
+      Send node,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_COMPOUND,
+        operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedSuperPrefix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_PREFIX,
+        operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperPostfix(
+      Send node,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_POSTFIX,
+        operator: operator));
+  }
+
+  @override
   visitTopLevelMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement visitTopLevelMethodSetterCompound
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_COMPOUND,
+        getter: method, setter: setter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
   visitCompoundIndexSet(
       Send node,
       Node receiver,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       arg) {
@@ skipping 14 matching lines @@
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_COMPOUND_INDEX_SET,
         getter: getter, setter: setter,
         index: index, rhs: rhs, operator: operator));
     apply(index, arg);
     apply(rhs, arg);
   }
 
   @override
-  errorClassTypeLiteralCompound(
+  visitClassTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  errorDynamicTypeLiteralCompound(
+  visitDynamicTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  errorTypeVariableTypeLiteralCompound(
+  visitTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
         element: element, operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  errorTypedefTypeLiteralCompound(
+  visitTypedefTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  errorLocalFunctionPrefix(
+  visitLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
-    // TODO: implement errorLocalFunctionPrefix
+    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_PREFIX,
+        element: function, operator: operator));
   }
 
   @override
-  errorClassTypeLiteralPrefix(
+  visitClassTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  errorDynamicTypeLiteralPrefix(
+  visitDynamicTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   visitLocalVariablePrefix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_PREFIX,
@@ skipping 31 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitStaticMethodSetterPrefix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitStaticMethodSetterPrefix
+    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_PREFIX,
+        getter: getter, setter: setter, operator: operator));
   }
 
   @override
+  visitSuperFieldFieldCompound(
+      Send node,
+      FieldElement readField,
+      FieldElement writtenField,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_COMPOUND,
+        getter: readField, setter: writtenField, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
   visitSuperFieldFieldPrefix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitSuperFieldFieldPrefix
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_PREFIX,
+        getter: readField, setter: writtenField, operator: operator));
   }
 
   @override
   visitSuperFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_PREFIX,
         element: field, operator: operator));
   }
 
   @override
+  visitSuperFinalFieldPrefix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_PREFIX,
+        element: field, operator: operator));
+  }
+
+  @override
   visitSuperFieldSetterPrefix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_PREFIX,
         getter: field, setter: setter, operator: operator));
   }
 
@@ skipping 19 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitSuperMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitSuperMethodSetterPrefix
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_PREFIX,
+        getter: method, setter: setter, operator: operator));
   }
 
   @override
   visitThisPropertyPrefix(
       Send node,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_PREFIX,
@@ skipping 22 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitTopLevelMethodSetterPrefix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitTopLevelMethodSetterPrefix
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_PREFIX,
+        getter: method, setter: setter, operator: operator));
   }
 
   @override
-  errorTypeVariableTypeLiteralPrefix(
+  visitTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
         element: element, operator: operator));
   }
 
   @override
-  errorTypedefTypeLiteralPrefix(
+  visitTypedefTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  errorLocalFunctionPostfix(
+  visitLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
-    // TODO: implement errorLocalFunctionPostfix
+    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_POSTFIX,
+        element: function, operator: operator));
   }
 
   @override
-  errorClassTypeLiteralPostfix(
+  visitClassTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  errorDynamicTypeLiteralPostfix(
+  visitDynamicTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
   visitLocalVariablePostfix(
       Send node,
       LocalVariableElement variable,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_POSTFIX,
@@ skipping 31 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitStaticMethodSetterPostfix(
       Send node,
       FunctionElement getter,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitStaticMethodSetterPostfix
+    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_POSTFIX,
+        getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitSuperFieldFieldPostfix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitSuperFieldFieldPostfix
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_POSTFIX,
+        getter: readField, setter: writtenField, operator: operator));
   }
 
   @override
   visitSuperFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_POSTFIX,
         element: field, operator: operator));
   }
 
   @override
+  visitSuperFinalFieldPostfix(
+      Send node,
+      FieldElement field,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_POSTFIX,
+        element: field, operator: operator));
+  }
+
+  @override
   visitSuperFieldSetterPostfix(
       Send node,
       FieldElement field,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_SETTER_POSTFIX,
         getter: field, setter: setter, operator: operator));
   }
 
@@ skipping 19 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitSuperMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitSuperMethodSetterPostfix
+    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_POSTFIX,
+        getter: method, setter: setter, operator: operator));
   }
 
   @override
   visitThisPropertyPostfix(
       Send node,
       IncDecOperator operator,
       Selector getterSelector,
       Selector setterSelector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_THIS_PROPERTY_POSTFIX,
@@ skipping 22 matching lines @@
         getter: getter, setter: setter, operator: operator));
   }
 
   @override
   visitTopLevelMethodSetterPostfix(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       IncDecOperator operator,
       arg) {
-    // TODO: implement visitTopLevelMethodSetterPostfix
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_POSTFIX,
+        getter: method, setter: setter, operator: operator));
   }
 
   @override
-  errorTypeVariableTypeLiteralPostfix(
+  visitTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
         element: element, operator: operator));
   }
 
   @override
-  errorTypedefTypeLiteralPostfix(
+  visitTypedefTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitConstantGet(
-      Send node,
-      ConstantExpression constant,
-      arg) {
-    // TODO: implement visitConstantGet
-  }
-
-  @override
-  visitConstantInvoke(
-      Send node,
-      ConstantExpression constant,
-      NodeList arguments,
-      CallStructure callStructure,
-      arg) {
-    // TODO: implement visitConstantInvoke
-  }
-
-  @override
-  errorUnresolvedCompound(
+  visitUnresolvedCompound(
       Send node,
       ErroneousElement element,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    // TODO: implement errorUnresolvedCompound
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_COMPOUND,
+        operator: operator, rhs: rhs));
+    apply(rhs, arg);
   }
 
   @override
   visitUnresolvedGet(
       Send node,
       Element element,
       arg) {
+    print('visitUnresolvedGet:$node:$element');
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_GET, name: element.name));
   }
 
   @override
   visitUnresolvedInvoke(
       Send node,
       Element element,
       NodeList arguments,
       Selector selector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_INVOKE,
         name: element.name, arguments: arguments));
   }
 
   @override
-  errorUnresolvedPostfix(
+  visitUnresolvedPostfix(
       Send node,
       ErroneousElement element,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(
-        VisitKind.ERROR_UNRESOLVED_POSTFIX, operator: operator));
+        VisitKind.VISIT_UNRESOLVED_POSTFIX, operator: operator));
   }
 
   @override
-  errorUnresolvedPrefix(
+  visitUnresolvedPrefix(
       Send node,
       ErroneousElement element,
       IncDecOperator operator,
       arg) {
-    // TODO: implement errorUnresolvedPrefix
+    visits.add(new Visit(
+        VisitKind.VISIT_UNRESOLVED_PREFIX, operator: operator));
   }
 
   @override
-  errorUnresolvedSet(
-      Send node,
-      ErroneousElement element,
-      Node rhs,
-      arg) {
-    // TODO: implement errorUnresolvedSet
-  }
-
-  @override
-  errorUndefinedBinaryExpression(
-      Send node,
-      Node left,
-      Operator operator,
-      Node right,
-      arg) {
-    // TODO: implement errorUndefinedBinaryExpression
-  }
-
-  @override
-  errorUndefinedUnaryExpression(
-      Send node,
-      Operator operator,
-      Node expression,
-      arg) {
-    // TODO: implement errorUndefinedUnaryExpression
-  }
-
-  @override
   visitUnresolvedSuperGetterCompoundIndexSet(
       Send node,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       arg) {
     visits.add(new Visit(
         VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
         index: index, operator: operator, rhs: rhs));
@@ skipping 271 matching lines @@
       CallStructure callStructure,
       arg) {
     visits.add(new Visit(
         VisitKind.VISIT_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
         element: constructor,
         type: type,
         arguments: arguments,
         selector: callStructure));
     apply(arguments, arg);
   }
+
+  @override
+  visitUnresolvedStaticGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_COMPOUND,
+        setter: setter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedTopLevelGetterCompound(
+      Send node,
+      Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_COMPOUND,
+        setter: setter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedStaticSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_COMPOUND,
+        getter: getter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedTopLevelSetterCompound(
+      Send node,
+      MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_COMPOUND,
+        getter: getter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitStaticMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_COMPOUND,
+        element: method, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitTopLevelMethodCompound(
+      Send node,
+      MethodElement method,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_COMPOUND,
+        element: method, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedStaticGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_PREFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedTopLevelGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_PREFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedStaticSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_PREFIX,
+        getter: getter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedTopLevelSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_PREFIX,
+        getter: getter, operator: operator));
+  }
+
+  @override
+  visitStaticMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_PREFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitTopLevelMethodPrefix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_PREFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitUnresolvedStaticGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_GETTER_POSTFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedTopLevelGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_GETTER_POSTFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedStaticSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_STATIC_SETTER_POSTFIX,
+        getter: getter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedTopLevelSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_TOP_LEVEL_SETTER_POSTFIX,
+        getter: getter, operator: operator));
+  }
+
+  @override
+  visitStaticMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_POSTFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitTopLevelMethodPostfix(
+      Send node,
+      MethodElement method,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_POSTFIX,
+        element: method, operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperGetterCompound(
+      Send node, Element element,
+      MethodElement setter,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND,
+        setter: setter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedSuperGetterPostfix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_POSTFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperGetterPrefix(
+      Send node,
+      Element element,
+      MethodElement setter,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_PREFIX,
+        setter: setter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperSetterCompound(
+      Send node, MethodElement getter,
+      Element element,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND,
+        getter: getter, operator: operator, rhs: rhs));
+    apply(rhs, arg);
+  }
+
+  @override
+  visitUnresolvedSuperSetterPostfix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_POSTFIX,
+        getter: getter, operator: operator));
+  }
+
+  @override
+  visitUnresolvedSuperSetterPrefix(
+      Send node,
+      MethodElement getter,
+      Element element,
+      IncDecOperator operator,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_PREFIX,
+        getter: getter, operator: operator));
+  }
 }
 
 class SemanticDeclarationTestVisitor extends SemanticTestVisitor {
 
   SemanticDeclarationTestVisitor(TreeElements elements) : super(elements);
 
   @override
   errorUnresolvedSuperConstructorInvoke(
       Send node,
       Element element,
@@ skipping 237 matching lines @@
       VariableDefinitions node,
       Node definition,
       LocalVariableElement variable,
       Node initializer,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_DECL,
         element: variable, rhs: initializer));
     if (initializer != null) {
       apply(initializer, arg);
     }
-    return null;
   }
 
   @override
   visitLocalConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       LocalVariableElement variable,
       ConstantExpression constant,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_CONSTANT_DECL,
         element: variable, constant: constant.getText()));
-    return null;
   }
 
   @override
   visitNamedInitializingFormalDeclaration(
       VariableDefinitions node,
       Node definition,
       InitializingFormalElement initializingFormal,
       ConstantExpression defaultValue,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_NAMED_INITIALIZING_FORMAL_DECL,
@@ skipping 32 matching lines @@
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_INSTANCE_FIELD_DECL,
         element: field, rhs: initializer));
     if (initializer != null) {
       apply(initializer, arg);
     }
-    return null;
   }
 
   @override
   visitStaticConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       ConstantExpression constant,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_STATIC_CONSTANT_DECL,
         element: field, constant: constant.getText()));
-    return null;
   }
 
   @override
   visitStaticFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_STATIC_FIELD_DECL,
         element: field, rhs: initializer));
     if (initializer != null) {
       apply(initializer, arg);
     }
-    return null;
   }
 
   @override
   visitTopLevelConstantDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       ConstantExpression constant,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_CONSTANT_DECL,
         element: field, constant: constant.getText()));
-    return null;
   }
 
   @override
   visitTopLevelFieldDeclaration(
       VariableDefinitions node,
       Node definition,
       FieldElement field,
       Node initializer,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_DECL,
         element: field, rhs: initializer));
     if (initializer != null) {
       apply(initializer, arg);
     }
-    return null;
   }
 
   @override
   visitAbstractGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_ABSTRACT_GETTER_DECL,
         element: getter));
-    return null;
   }
 
   @override
   visitAbstractSetterDeclaration(
       FunctionExpression node,
       MethodElement setter,
       NodeList parameters,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_ABSTRACT_SETTER_DECL,
         element: setter, parameters: parameters));
     applyParameters(parameters, arg);
-    return null;
   }
 
   @override
   visitInstanceGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_INSTANCE_GETTER_DECL,
         element: getter, body: body));
     apply(body, arg);
-    return null;
   }
 
   @override
   visitInstanceSetterDeclaration(
       FunctionExpression node,
       MethodElement setter,
       NodeList parameters,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_INSTANCE_SETTER_DECL,
         element: setter, parameters: parameters, body: body));
     applyParameters(parameters, arg);
     apply(body, arg);
-    return null;
   }
 
   @override
   visitTopLevelGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_DECL,
         element: getter, body: body));
     apply(body, arg);
-    return null;
   }
 
   @override
   visitTopLevelSetterDeclaration(
       FunctionExpression node,
       MethodElement setter,
       NodeList parameters,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_SETTER_DECL,
         element: setter, parameters: parameters, body: body));
     applyParameters(parameters, arg);
     apply(body, arg);
-    return null;
   }
 
   @override
   visitStaticGetterDeclaration(
       FunctionExpression node,
       MethodElement getter,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_STATIC_GETTER_DECL,
         element: getter, body: body));
     apply(body, arg);
-    return null;
   }
 
   @override
   visitStaticSetterDeclaration(
       FunctionExpression node,
       MethodElement setter,
       NodeList parameters,
       Node body,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_STATIC_SETTER_DECL,
         element: setter, parameters: parameters, body: body));
     applyParameters(parameters, arg);
     apply(body, arg);
-    return null;
   }
 
   @override
   visitUnresolvedClassConstructorInvoke(
       NewExpression node,
       Element constructor,
       MalformedType type,
       NodeList arguments,
       Selector selector,
       arg) {
@@ skipping 135 matching lines @@
   }
 }
 
 enum VisitKind {
   VISIT_PARAMETER_GET,
   VISIT_PARAMETER_SET,
   VISIT_PARAMETER_INVOKE,
   VISIT_PARAMETER_COMPOUND,
   VISIT_PARAMETER_PREFIX,
   VISIT_PARAMETER_POSTFIX,
+  VISIT_FINAL_PARAMETER_COMPOUND,
+  VISIT_FINAL_PARAMETER_PREFIX,
+  VISIT_FINAL_PARAMETER_POSTFIX,
 
   VISIT_LOCAL_VARIABLE_GET,
   VISIT_LOCAL_VARIABLE_SET,
   VISIT_LOCAL_VARIABLE_INVOKE,
   VISIT_LOCAL_VARIABLE_COMPOUND,
   VISIT_LOCAL_VARIABLE_PREFIX,
   VISIT_LOCAL_VARIABLE_POSTFIX,
   VISIT_LOCAL_VARIABLE_DECL,
   VISIT_LOCAL_CONSTANT_DECL,
+  VISIT_FINAL_LOCAL_VARIABLE_COMPOUND,
+  VISIT_FINAL_LOCAL_VARIABLE_PREFIX,
+  VISIT_FINAL_LOCAL_VARIABLE_POSTFIX,
 
   VISIT_LOCAL_FUNCTION_GET,
   VISIT_LOCAL_FUNCTION_INVOKE,
   VISIT_LOCAL_FUNCTION_DECL,
   VISIT_CLOSURE_DECL,
+  VISIT_LOCAL_FUNCTION_COMPOUND,
+  VISIT_LOCAL_FUNCTION_PREFIX,
+  VISIT_LOCAL_FUNCTION_POSTFIX,
 
   VISIT_STATIC_FIELD_GET,
   VISIT_STATIC_FIELD_SET,
   VISIT_STATIC_FIELD_INVOKE,
   VISIT_STATIC_FIELD_COMPOUND,
   VISIT_STATIC_FIELD_PREFIX,
   VISIT_STATIC_FIELD_POSTFIX,
   VISIT_STATIC_FIELD_DECL,
   VISIT_STATIC_CONSTANT_DECL,
 
   VISIT_STATIC_GETTER_GET,
   VISIT_STATIC_SETTER_SET,
   VISIT_STATIC_GETTER_INVOKE,
   VISIT_STATIC_GETTER_SETTER_COMPOUND,
   VISIT_STATIC_METHOD_SETTER_COMPOUND,
   VISIT_STATIC_GETTER_SETTER_PREFIX,
   VISIT_STATIC_GETTER_SETTER_POSTFIX,
   VISIT_STATIC_GETTER_DECL,
   VISIT_STATIC_SETTER_DECL,
+  VISIT_STATIC_FINAL_FIELD_COMPOUND,
+  VISIT_STATIC_FINAL_FIELD_POSTFIX,
+  VISIT_STATIC_FINAL_FIELD_PREFIX,
 
   VISIT_STATIC_FUNCTION_GET,
   VISIT_STATIC_FUNCTION_INVOKE,
   VISIT_STATIC_FUNCTION_INCOMPATIBLE_INVOKE,
   VISIT_STATIC_FUNCTION_DECL,
+  VISIT_STATIC_METHOD_SETTER_PREFIX,
+  VISIT_STATIC_METHOD_SETTER_POSTFIX,
+
+  VISIT_UNRESOLVED_STATIC_GETTER_COMPOUND,
+  VISIT_UNRESOLVED_STATIC_SETTER_COMPOUND,
+  VISIT_STATIC_METHOD_COMPOUND,
+  VISIT_UNRESOLVED_STATIC_GETTER_PREFIX,
+  VISIT_UNRESOLVED_STATIC_SETTER_PREFIX,
+  VISIT_STATIC_METHOD_PREFIX,
+  VISIT_UNRESOLVED_STATIC_GETTER_POSTFIX,
+  VISIT_UNRESOLVED_STATIC_SETTER_POSTFIX,
+  VISIT_STATIC_METHOD_POSTFIX,
 
   VISIT_TOP_LEVEL_FIELD_GET,
   VISIT_TOP_LEVEL_FIELD_SET,
   VISIT_TOP_LEVEL_FIELD_INVOKE,
   VISIT_TOP_LEVEL_FIELD_COMPOUND,
   VISIT_TOP_LEVEL_FIELD_PREFIX,
   VISIT_TOP_LEVEL_FIELD_POSTFIX,
   VISIT_TOP_LEVEL_FIELD_DECL,
   VISIT_TOP_LEVEL_CONSTANT_DECL,
+  VISIT_TOP_LEVEL_FINAL_FIELD_COMPOUND,
+  VISIT_TOP_LEVEL_FINAL_FIELD_POSTFIX,
+  VISIT_TOP_LEVEL_FINAL_FIELD_PREFIX,
 
   VISIT_TOP_LEVEL_GETTER_GET,
   VISIT_TOP_LEVEL_SETTER_SET,
   VISIT_TOP_LEVEL_GETTER_INVOKE,
   VISIT_TOP_LEVEL_GETTER_SETTER_COMPOUND,
   VISIT_TOP_LEVEL_GETTER_SETTER_PREFIX,
   VISIT_TOP_LEVEL_GETTER_SETTER_POSTFIX,
   VISIT_TOP_LEVEL_GETTER_DECL,
   VISIT_TOP_LEVEL_SETTER_DECL,
 
   VISIT_TOP_LEVEL_FUNCTION_GET,
   VISIT_TOP_LEVEL_FUNCTION_INVOKE,
   VISIT_TOP_LEVEL_FUNCTION_INCOMPATIBLE_INVOKE,
   VISIT_TOP_LEVEL_FUNCTION_DECL,
+  VISIT_TOP_LEVEL_METHOD_SETTER_COMPOUND,
+  VISIT_TOP_LEVEL_METHOD_SETTER_PREFIX,
+  VISIT_TOP_LEVEL_METHOD_SETTER_POSTFIX,
+
+  VISIT_UNRESOLVED_TOP_LEVEL_GETTER_COMPOUND,
+  VISIT_UNRESOLVED_TOP_LEVEL_SETTER_COMPOUND,
+  VISIT_TOP_LEVEL_METHOD_COMPOUND,
+  VISIT_UNRESOLVED_TOP_LEVEL_GETTER_PREFIX,
+  VISIT_UNRESOLVED_TOP_LEVEL_SETTER_PREFIX,
+  VISIT_TOP_LEVEL_METHOD_PREFIX,
+  VISIT_UNRESOLVED_TOP_LEVEL_GETTER_POSTFIX,
+  VISIT_UNRESOLVED_TOP_LEVEL_SETTER_POSTFIX,
+  VISIT_TOP_LEVEL_METHOD_POSTFIX,
 
   VISIT_DYNAMIC_PROPERTY_GET,
   VISIT_DYNAMIC_PROPERTY_SET,
   VISIT_DYNAMIC_PROPERTY_INVOKE,
   VISIT_DYNAMIC_PROPERTY_COMPOUND,
   VISIT_DYNAMIC_PROPERTY_PREFIX,
   VISIT_DYNAMIC_PROPERTY_POSTFIX,
 
   VISIT_THIS_GET,
   VISIT_THIS_INVOKE,
 
   VISIT_THIS_PROPERTY_GET,
   VISIT_THIS_PROPERTY_SET,
   VISIT_THIS_PROPERTY_INVOKE,
   VISIT_THIS_PROPERTY_COMPOUND,
   VISIT_THIS_PROPERTY_PREFIX,
   VISIT_THIS_PROPERTY_POSTFIX,
 
   VISIT_SUPER_FIELD_GET,
   VISIT_SUPER_FIELD_SET,
   VISIT_SUPER_FIELD_INVOKE,
   VISIT_SUPER_FIELD_COMPOUND,
   VISIT_SUPER_FIELD_PREFIX,
   VISIT_SUPER_FIELD_POSTFIX,
+  VISIT_SUPER_FINAL_FIELD_COMPOUND,
+  VISIT_SUPER_FINAL_FIELD_PREFIX,
+  VISIT_SUPER_FINAL_FIELD_POSTFIX,
+  VISIT_SUPER_FIELD_FIELD_COMPOUND,
+  VISIT_SUPER_FIELD_FIELD_PREFIX,
+  VISIT_SUPER_FIELD_FIELD_POSTFIX,
 
   VISIT_SUPER_GETTER_GET,
   VISIT_SUPER_SETTER_SET,
   VISIT_SUPER_GETTER_INVOKE,
   VISIT_SUPER_GETTER_SETTER_COMPOUND,
   VISIT_SUPER_GETTER_FIELD_COMPOUND,
   VISIT_SUPER_FIELD_SETTER_COMPOUND,
   VISIT_SUPER_GETTER_SETTER_PREFIX,
   VISIT_SUPER_GETTER_FIELD_PREFIX,
   VISIT_SUPER_FIELD_SETTER_PREFIX,
   VISIT_SUPER_GETTER_SETTER_POSTFIX,
   VISIT_SUPER_GETTER_FIELD_POSTFIX,
   VISIT_SUPER_FIELD_SETTER_POSTFIX,
 
   VISIT_SUPER_METHOD_GET,
   VISIT_SUPER_METHOD_INVOKE,
   VISIT_SUPER_METHOD_INCOMPATIBLE_INVOKE,
+  VISIT_SUPER_METHOD_SETTER_COMPOUND,
+  VISIT_SUPER_METHOD_SETTER_PREFIX,
+  VISIT_SUPER_METHOD_SETTER_POSTFIX,
+  VISIT_SUPER_METHOD_COMPOUND,
+  VISIT_SUPER_METHOD_PREFIX,
+  VISIT_SUPER_METHOD_POSTFIX,
 
   VISIT_UNRESOLVED_GET,
   VISIT_UNRESOLVED_INVOKE,
   VISIT_UNRESOLVED_SUPER_GET,
   VISIT_UNRESOLVED_SUPER_INVOKE,
 
   VISIT_BINARY,
   VISIT_INDEX,
   VISIT_EQUALS,
   VISIT_NOT_EQUALS,
   VISIT_INDEX_PREFIX,
   VISIT_INDEX_POSTFIX,
 
   VISIT_SUPER_BINARY,
   VISIT_UNRESOLVED_SUPER_BINARY,
   VISIT_SUPER_INDEX,
   VISIT_UNRESOLVED_SUPER_INDEX,
   VISIT_SUPER_EQUALS,
   VISIT_SUPER_NOT_EQUALS,
   VISIT_SUPER_INDEX_PREFIX,
+  VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND,
+  VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND,
+  VISIT_UNRESOLVED_SUPER_GETTER_PREFIX,
+  VISIT_UNRESOLVED_SUPER_SETTER_PREFIX,
   VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
   VISIT_UNRESOLVED_SUPER_SETTER_INDEX_PREFIX,
   VISIT_SUPER_INDEX_POSTFIX,
+  VISIT_UNRESOLVED_SUPER_GETTER_POSTFIX,
+  VISIT_UNRESOLVED_SUPER_SETTER_POSTFIX,
   VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
   VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX,
 
+  VISIT_UNRESOLVED_SUPER_COMPOUND,
+  VISIT_UNRESOLVED_SUPER_PREFIX,
+  VISIT_UNRESOLVED_SUPER_POSTFIX,
+
   VISIT_UNARY,
   VISIT_SUPER_UNARY,
   VISIT_UNRESOLVED_SUPER_UNARY,
   VISIT_NOT,
 
   VISIT_EXPRESSION_INVOKE,
 
   VISIT_CLASS_TYPE_LITERAL_GET,
   VISIT_CLASS_TYPE_LITERAL_SET,
   VISIT_CLASS_TYPE_LITERAL_INVOKE,
-  VISIT_CLASS_TYPE_LITERAL_BINARY,
-  ERROR_CLASS_TYPE_LITERAL_COMPOUND,
-  ERROR_CLASS_TYPE_LITERAL_PREFIX,
-  ERROR_CLASS_TYPE_LITERAL_POSTFIX,
+  VISIT_CLASS_TYPE_LITERAL_COMPOUND,
+  VISIT_CLASS_TYPE_LITERAL_PREFIX,
+  VISIT_CLASS_TYPE_LITERAL_POSTFIX,
 
   VISIT_TYPEDEF_TYPE_LITERAL_GET,
   VISIT_TYPEDEF_TYPE_LITERAL_SET,
   VISIT_TYPEDEF_TYPE_LITERAL_INVOKE,
-  VISIT_TYPEDEF_TYPE_LITERAL_BINARY,
-  ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
-  ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
-  ERROR_TYPEDEF_TYPE_LITERAL_POSTFIX,
+  VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
+  VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
+  VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
 
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_GET,
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_SET,
   VISIT_TYPE_VARIABLE_TYPE_LITERAL_INVOKE,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_BINARY,
-  ERROR_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
-  ERROR_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
-  ERROR_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+  VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+  VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+  VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
 
   VISIT_DYNAMIC_TYPE_LITERAL_GET,
   VISIT_DYNAMIC_TYPE_LITERAL_SET,
   VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
-  VISIT_DYNAMIC_TYPE_LITERAL_BINARY,
-  ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
-  ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
-  ERROR_DYNAMIC_TYPE_LITERAL_POSTFIX,
+  VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
+  VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
+  VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
 
   VISIT_INDEX_SET,
   VISIT_COMPOUND_INDEX_SET,
   VISIT_SUPER_INDEX_SET,
   VISIT_UNRESOLVED_SUPER_INDEX_SET,
   VISIT_SUPER_COMPOUND_INDEX_SET,
   VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
   VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET,
 
   VISIT_ASSERT,
@@ skipping 31 matching lines @@
   VISIT_FACTORY_CONSTRUCTOR_DECL,
   VISIT_REDIRECTING_FACTORY_CONSTRUCTOR_DECL,
 
   VISIT_REQUIRED_PARAMETER_DECL,
   VISIT_OPTIONAL_PARAMETER_DECL,
   VISIT_NAMED_PARAMETER_DECL,
   VISIT_REQUIRED_INITIALIZING_FORMAL_DECL,
   VISIT_OPTIONAL_INITIALIZING_FORMAL_DECL,
   VISIT_NAMED_INITIALIZING_FORMAL_DECL,
 
-  ERROR_UNRESOLVED_POSTFIX,
+  VISIT_UNRESOLVED_COMPOUND,
+  VISIT_UNRESOLVED_PREFIX,
+  VISIT_UNRESOLVED_POSTFIX,
 
   // TODO(johnniwinther): Add tests for more error cases.
 }