Revert "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 1232 matching lines @@
     const Test.clazz(
         '''
         class B {
           operator []=(a, b) {}
         }
         class C extends B {
           m() => ++super[42];
         }
         ''',
         const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
-                    setter: 'function(B#[]=)',
                     index: '42',
                     operator: '++')),
     const Test.clazz(
         '''
         class B {
         }
         class C extends B {
           m() => ++super[42];
         }
         ''',
-        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_PREFIX,
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
                     index: '42',
                     operator: '++')),
     const Test.clazz(
         '''
         class B {
           operator [](_) => null;
         }
         class C extends B {
           m() => ++super[42];
         }
@@ skipping 20 matching lines @@
     const Test.clazz(
         '''
         class B {
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[42]--;
         }
         ''',
         const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
-                    setter: 'function(B#[]=)',
                     index: '42',
                     operator: '--')),
     const Test.clazz(
         '''
         class B {
         }
         class C extends B {
           m() => super[42]--;
         }
         ''',
-        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_POSTFIX,
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
                     index: '42',
                     operator: '--')),
     const Test.clazz(
         '''
         class B {
           operator [](_) => null;
         }
         class C extends B {
           m() => super[42]--;
         }
@@ skipping 174 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 12 matching lines @@
     const Test.clazz(
         '''
         class B {
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[1] += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
-            setter: 'function(B#[]=)',
             index: '1', operator: '+=', rhs: '42')),
     const Test.clazz(
         '''
         class B {
         }
         class C extends B {
           m() => super[1] += 42;
         }
         ''',
-        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_COMPOUND_INDEX_SET,
+        const Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
             index: '1', operator: '+=', rhs: '42')),
     const Test.clazz(
         '''
         class B {
           operator [](_) {}
         }
         class C extends B {
           m() => super[1] += 42;
         }
         ''',
@@ skipping 16 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(
         '''
-        class C {
-          static a(var value) { }
-        }
-        m() => C.a++;
+        set topLevel(var value) { }
+        m() => topLevel++;
         ''',
-        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,
+        const Visit(VisitKind.ERROR_UNRESOLVED_POSTFIX,
             operator: '++')),
   ],
   'Constructor invocations': const [
     const Test(
         '''
         class Class {
           const Class(a, b);
         }
         m() => const Class(true, 42);
         ''',
@@ skipping 152 matching lines @@
           factory Class(a, b) = AbstractClass;
         }
         m() => new Class(true, 42);
         ''',
         const Visit(
             VisitKind.VISIT_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
             element: 'function(Class#)',
             arguments: '(true,42)',
             type: 'Class',
             selector: 'CallStructure(arity=2)')),
+    const Test(
+        '''
+        class Class {}
+        m() => const Class();
+        ''',
+        const Visit(VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
+            arguments: '()',
+            type: 'Class',
+            selector: 'CallStructure(arity=0)')),
+    const Test(
+        '''
+        class Class {
+          const Class() // Delibrate syntax error.
+        }
+        m() => const Class();
+        ''',
+        const Visit(VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
+            arguments: '()',
+            type: 'dynamic',
+            selector: 'CallStructure(arity=0)')),
+    const Test(
+        '''
+        class Target {}
+        class Class {
+          const factory Class() = Target;
+        }
+        m() => const Class();
+        ''',
+        const Visit(VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
+            arguments: '()',
+            type: 'Class',
+            selector: 'CallStructure(arity=0)')),
+    /* Enable this when constness is handled consistently.
+    const Test(
+        '''
+        class Target {
+          const Target();
+        }
+        class Redirection {
+          factory Redirection() = Target;
+        }
+        class Class {
+          const factory Class() = Redirection;
+        }
+        m() => const Class();
+        ''',
+        const Visit(VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
+            arguments: '()',
+            type: 'Class',
+            selector: 'CallStructure(arity=0)')),
+    */
   ],
 };
 
 const Map<String, List<Test>> DECL_TESTS = const {
   'Function declarations': const [
     const Test(
         '''
         m(a, b) {}
         ''',
         const [
@@ skipping 803 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(Set<VisitKind> unvisitedKinds,
-            List<String> arguments,
+Future test(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) {
       StringBuffer testSource = new StringBuffer();
       if (test.codeByPrefix != null) {
         String prefixFilename = 'pre$index.dart';
         sourceFiles[prefixFilename] = test.codeByPrefix;
         testSource.writeln("import '$prefixFilename' as p;");
       }
 
       String filename = 'lib$index.dart';
       testSource.writeln(test.code);
       sourceFiles[filename] = testSource.toString();
       mainSource.writeln("import '$filename';");
       testMap[filename] = test;
       index++;
     });
   });
+
   mainSource.writeln("main() {}");
   sourceFiles['main.dart'] = mainSource.toString();
 
   Compiler compiler = compilerFor(sourceFiles,
       options: ['--analyze-all', '--analyze-only']);
   return compiler.run(Uri.parse('memory:main.dart')).then((_) {
     testMap.forEach((String filename, Test test) {
       LibraryElement library = compiler.libraryLoader.lookupLibrary(
           Uri.parse('memory:$filename'));
       var expectedVisits = test.expectedVisits;
@@ skipping 23 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
-  visitFinalLocalVariableCompound(
+  errorFinalLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_FINAL_LOCAL_VARIABLE_COMPOUND,
-        element: variable, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
-  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(
+    // TODO: implement errorFinalLocalVariableCompound
+  }
+
+  @override
+  errorFinalParameterCompound(
       Send node,
       ParameterElement parameter,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_FINAL_PARAMETER_COMPOUND,
-        element: parameter, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
-  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
-  visitFinalStaticFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_COMPOUND,
-        element: field, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
-  visitFinalStaticFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_POSTFIX,
-        element: field, operator: operator));
-  }
-
-  @override
-  visitFinalStaticFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_STATIC_FINAL_FIELD_PREFIX,
-        element: field, operator: operator));
-  }
-
-  @override
-  visitFinalSuperFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_FINAL_FIELD_COMPOUND,
-        element: field, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
-  visitFinalTopLevelFieldCompound(
-      Send node,
-      FieldElement field,
-      AssignmentOperator operator,
-      Node rhs,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_COMPOUND,
-        element: field, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
-  visitFinalTopLevelFieldPostfix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_POSTFIX,
-        element: field, operator: operator));
-  }
-
-  @override
-  visitFinalTopLevelFieldPrefix(
-      Send node,
-      FieldElement field,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_FINAL_FIELD_PREFIX,
-        element: field, operator: operator));
-  }
-
-  @override
-  visitLocalFunctionCompound(
+    // TODO: implement errorFinalParameterCompound
+  }
+
+  @override
+  errorFinalStaticFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    // TODO: implement errorFinalStaticFieldCompound
+  }
+
+  @override
+  errorFinalSuperFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    // TODO: implement errorFinalSuperFieldCompound
+  }
+
+  @override
+  errorFinalTopLevelFieldCompound(
+      Send node,
+      FieldElement field,
+      AssignmentOperator operator,
+      Node rhs,
+      arg) {
+    // TODO: implement errorFinalTopLevelFieldCompound
+  }
+
+  @override
+  errorLocalFunctionCompound(
       Send node,
       LocalFunctionElement function,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_COMPOUND,
-        element: function, operator: operator, rhs: rhs));
-    apply(rhs, arg);
-  }
-
-  @override
+    // TODO: implement errorLocalFunctionCompound
+  }
+
+  @override
   visitLocalVariableCompound(
       Send node,
       LocalVariableElement variable,
       AssignmentOperator operator,
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_LOCAL_VARIABLE_COMPOUND,
         element: variable, operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
@@ skipping 145 matching lines @@
   }
 
   @override
   visitSuperMethodSetterCompound(
       Send node,
       FunctionElement method,
       FunctionElement setter,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_COMPOUND,
-        getter: method, setter: setter, operator: operator, rhs: rhs));
-    apply(rhs, arg);
+    // TODO: implement visitSuperMethodSetterCompound
   }
 
   @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) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_COMPOUND,
-        getter: method, setter: setter, operator: operator, rhs: rhs));
-    apply(rhs, arg);
+    // TODO: implement visitTopLevelMethodSetterCompound
   }
 
   @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
-  visitClassTypeLiteralCompound(
+  errorClassTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitDynamicTypeLiteralCompound(
+  errorDynamicTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitTypeVariableTypeLiteralCompound(
+  errorTypeVariableTypeLiteralCompound(
       Send node,
       TypeVariableElement element,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_COMPOUND,
         element: element, operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitTypedefTypeLiteralCompound(
+  errorTypedefTypeLiteralCompound(
       Send node,
       ConstantExpression constant,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
         constant: constant.getText(), operator: operator, rhs: rhs));
     apply(rhs, arg);
   }
 
   @override
-  visitLocalFunctionPrefix(
+  errorLocalFunctionPrefix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_PREFIX,
-        element: function, operator: operator));
+    // TODO: implement errorLocalFunctionPrefix
   }
 
   @override
-  visitClassTypeLiteralPrefix(
+  errorClassTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitDynamicTypeLiteralPrefix(
+  errorDynamicTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_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) {
-    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_PREFIX,
-        getter: getter, setter: setter, operator: operator));
+    // TODO: implement visitStaticMethodSetterPrefix
   }
 
   @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) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_PREFIX,
-        getter: readField, setter: writtenField, operator: operator));
+    // TODO: implement visitSuperFieldFieldPrefix
   }
 
   @override
   visitSuperFieldPrefix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_PREFIX,
         element: field, operator: operator));
   }
 
   @override
-  visitFinalSuperFieldPrefix(
-      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) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_PREFIX,
-        getter: method, setter: setter, operator: operator));
+    // TODO: implement visitSuperMethodSetterPrefix
   }
 
   @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) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_PREFIX,
-        getter: method, setter: setter, operator: operator));
+    // TODO: implement visitTopLevelMethodSetterPrefix
   }
 
   @override
-  visitTypeVariableTypeLiteralPrefix(
+  errorTypeVariableTypeLiteralPrefix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
         element: element, operator: operator));
   }
 
   @override
-  visitTypedefTypeLiteralPrefix(
+  errorTypedefTypeLiteralPrefix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitLocalFunctionPostfix(
+  errorLocalFunctionPostfix(
       Send node,
       LocalFunctionElement function,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_LOCAL_FUNCTION_POSTFIX,
-        element: function, operator: operator));
+    // TODO: implement errorLocalFunctionPostfix
   }
 
   @override
-  visitClassTypeLiteralPostfix(
+  errorClassTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_CLASS_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitDynamicTypeLiteralPostfix(
+  errorDynamicTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_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) {
-    visits.add(new Visit(VisitKind.VISIT_STATIC_METHOD_SETTER_POSTFIX,
-        getter: getter, setter: setter, operator: operator));
+    // TODO: implement visitStaticMethodSetterPostfix
   }
 
   @override
   visitSuperFieldFieldPostfix(
       Send node,
       FieldElement readField,
       FieldElement writtenField,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_FIELD_POSTFIX,
-        getter: readField, setter: writtenField, operator: operator));
+    // TODO: implement visitSuperFieldFieldPostfix
   }
 
   @override
   visitSuperFieldPostfix(
       Send node,
       FieldElement field,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_FIELD_POSTFIX,
         element: field, operator: operator));
   }
 
   @override
-  visitFinalSuperFieldPostfix(
-      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) {
-    visits.add(new Visit(VisitKind.VISIT_SUPER_METHOD_SETTER_POSTFIX,
-        getter: method, setter: setter, operator: operator));
+    // TODO: implement visitSuperMethodSetterPostfix
   }
 
   @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) {
-    visits.add(new Visit(VisitKind.VISIT_TOP_LEVEL_METHOD_SETTER_POSTFIX,
-        getter: method, setter: setter, operator: operator));
+    // TODO: implement visitTopLevelMethodSetterPostfix
   }
 
   @override
-  visitTypeVariableTypeLiteralPostfix(
+  errorTypeVariableTypeLiteralPostfix(
       Send node,
       TypeVariableElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
         element: element, operator: operator));
   }
 
   @override
-  visitTypedefTypeLiteralPostfix(
+  errorTypedefTypeLiteralPostfix(
       Send node,
       ConstantExpression constant,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
+    visits.add(new Visit(VisitKind.ERROR_TYPEDEF_TYPE_LITERAL_POSTFIX,
         constant: constant.getText(), operator: operator));
   }
 
   @override
-  visitUnresolvedCompound(
+  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(
       Send node,
       ErroneousElement element,
       AssignmentOperator operator,
       Node rhs,
       arg) {
-    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_COMPOUND,
-        operator: operator, rhs: rhs));
-    apply(rhs, arg);
+    // TODO: implement errorUnresolvedCompound
   }
 
   @override
   visitUnresolvedGet(
       Send node,
       Element element,
       arg) {
     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
-  visitUnresolvedPostfix(
+  errorUnresolvedPostfix(
       Send node,
       ErroneousElement element,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(
-        VisitKind.VISIT_UNRESOLVED_POSTFIX, operator: operator));
+        VisitKind.ERROR_UNRESOLVED_POSTFIX, operator: operator));
   }
 
   @override
-  visitUnresolvedPrefix(
+  errorUnresolvedPrefix(
       Send node,
       ErroneousElement element,
       IncDecOperator operator,
       arg) {
-    visits.add(new Visit(
-        VisitKind.VISIT_UNRESOLVED_PREFIX, operator: operator));
+    // TODO: implement errorUnresolvedPrefix
   }
 
   @override
-  visitUnresolvedSuperCompoundIndexSet(
+  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_COMPOUND_INDEX_SET,
+        VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
         index: index, operator: operator, rhs: rhs));
     apply(index, arg);
     apply(rhs, arg);
   }
-
-  @override
-  visitUnresolvedSuperGetterCompoundIndexSet(
-      Send node,
-      Element element,
-      MethodElement setter,
-      Node index,
-      AssignmentOperator operator,
-      Node rhs,
-      arg) {
-    visits.add(new Visit(
-        VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
-        setter: setter, index: index, operator: operator, rhs: rhs));
-    apply(index, arg);
-    apply(rhs, arg);
-  }
 
   @override
   visitUnresolvedSuperSetterCompoundIndexSet(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       AssignmentOperator operator,
       Node rhs,
       arg) {
@@ skipping 11 matching lines @@
       Node index,
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_SET,
                index: index, rhs: rhs));
     apply(index, arg);
     apply(rhs, arg);
   }
 
   @override
-  visitUnresolvedSuperIndexPostfix(
-      Send node,
-      Element element,
-      Node index,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_POSTFIX,
-               index: index, operator: operator));
-    apply(index, arg);
-  }
-
-  @override
   visitUnresolvedSuperGetterIndexPostfix(
       Send node,
       Element element,
-      MethodElement setter,
       Node index,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_POSTFIX,
-               setter: setter, index: index, operator: operator));
+               index: index, operator: operator));
     apply(index, arg);
   }
 
   @override
   visitUnresolvedSuperSetterIndexPostfix(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_SETTER_INDEX_POSTFIX,
                getter: getter, index: index, operator: operator));
     apply(index, arg);
   }
 
   @override
-  visitUnresolvedSuperIndexPrefix(
-      Send node,
-      Element element,
-      Node index,
-      IncDecOperator operator,
-      arg) {
-    visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_INDEX_PREFIX,
-               index: index, operator: operator));
-    apply(index, arg);
-  }
-
-  @override
   visitUnresolvedSuperGetterIndexPrefix(
       Send node,
       Element element,
-      MethodElement setter,
       Node index,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_UNRESOLVED_SUPER_GETTER_INDEX_PREFIX,
-               setter: setter, index: index, operator: operator));
+               index: index, operator: operator));
     apply(index, arg);
   }
 
   @override
   visitUnresolvedSuperSetterIndexPrefix(
       Send node,
       MethodElement getter,
       Element element,
       Node index,
       IncDecOperator operator,
@@ skipping 196 matching lines @@
     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,
+  errorNonConstantConstructorInvoke(
+      NewExpression node,
       Element element,
-      MethodElement setter,
-      AssignmentOperator operator,
-      Node rhs,
+      DartType type,
+      NodeList arguments,
+      CallStructure callStructure,
       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));
+    visits.add(new Visit(
+        VisitKind.ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
+        type: type,
+        arguments: arguments,
+        selector: callStructure));
+    apply(arguments, arg);
   }
 }
 
 class SemanticDeclarationTestVisitor extends SemanticTestVisitor {
 
   SemanticDeclarationTestVisitor(TreeElements elements) : super(elements);
 
   @override
   errorUnresolvedSuperConstructorInvoke(
       Send node,
@@ skipping 238 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_INDEX_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_INDEX_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_COMPOUND,
-  VISIT_CLASS_TYPE_LITERAL_PREFIX,
-  VISIT_CLASS_TYPE_LITERAL_POSTFIX,
+  VISIT_CLASS_TYPE_LITERAL_BINARY,
+  ERROR_CLASS_TYPE_LITERAL_COMPOUND,
+  ERROR_CLASS_TYPE_LITERAL_PREFIX,
+  ERROR_CLASS_TYPE_LITERAL_POSTFIX,
 
   VISIT_TYPEDEF_TYPE_LITERAL_GET,
   VISIT_TYPEDEF_TYPE_LITERAL_SET,
   VISIT_TYPEDEF_TYPE_LITERAL_INVOKE,
-  VISIT_TYPEDEF_TYPE_LITERAL_COMPOUND,
-  VISIT_TYPEDEF_TYPE_LITERAL_PREFIX,
-  VISIT_TYPEDEF_TYPE_LITERAL_POSTFIX,
+  VISIT_TYPEDEF_TYPE_LITERAL_BINARY,
+  ERROR_TYPEDEF_TYPE_LITERAL_COMPOUND,
+  ERROR_TYPEDEF_TYPE_LITERAL_PREFIX,
+  ERROR_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_COMPOUND,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_PREFIX,
-  VISIT_TYPE_VARIABLE_TYPE_LITERAL_POSTFIX,
+  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_DYNAMIC_TYPE_LITERAL_GET,
   VISIT_DYNAMIC_TYPE_LITERAL_SET,
   VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
-  VISIT_DYNAMIC_TYPE_LITERAL_COMPOUND,
-  VISIT_DYNAMIC_TYPE_LITERAL_PREFIX,
-  VISIT_DYNAMIC_TYPE_LITERAL_POSTFIX,
+  VISIT_DYNAMIC_TYPE_LITERAL_BINARY,
+  ERROR_DYNAMIC_TYPE_LITERAL_COMPOUND,
+  ERROR_DYNAMIC_TYPE_LITERAL_PREFIX,
+  ERROR_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_COMPOUND_INDEX_SET,
   VISIT_UNRESOLVED_SUPER_GETTER_COMPOUND_INDEX_SET,
   VISIT_UNRESOLVED_SUPER_SETTER_COMPOUND_INDEX_SET,
 
   VISIT_ASSERT,
   VISIT_LOGICAL_AND,
   VISIT_LOGICAL_OR,
   VISIT_IS,
   VISIT_IS_NOT,
   VISIT_AS,
 
   VISIT_CONST_CONSTRUCTOR_INVOKE,
   VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
   VISIT_REDIRECTING_GENERATIVE_CONSTRUCTOR_INVOKE,
   VISIT_FACTORY_CONSTRUCTOR_INVOKE,
   VISIT_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
 
   VISIT_SUPER_CONSTRUCTOR_INVOKE,
   VISIT_THIS_CONSTRUCTOR_INVOKE,
   VISIT_FIELD_INITIALIZER,
 
   VISIT_UNRESOLVED_CLASS_CONSTRUCTOR_INVOKE,
   VISIT_UNRESOLVED_CONSTRUCTOR_INVOKE,
   VISIT_ABSTRACT_CLASS_CONSTRUCTOR_INVOKE,
   VISIT_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+  ERROR_NON_CONSTANT_CONSTRUCTOR_INVOKE,
 
   VISIT_INSTANCE_GETTER_DECL,
   VISIT_INSTANCE_SETTER_DECL,
   VISIT_INSTANCE_METHOD_DECL,
   VISIT_ABSTRACT_GETTER_DECL,
   VISIT_ABSTRACT_SETTER_DECL,
   VISIT_ABSTRACT_METHOD_DECL,
   VISIT_INSTANCE_FIELD_DECL,
 
   VISIT_GENERATIVE_CONSTRUCTOR_DECL,
   VISIT_REDIRECTING_GENERATIVE_CONSTRUCTOR_DECL,
   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,
 
-  VISIT_UNRESOLVED_COMPOUND,
-  VISIT_UNRESOLVED_PREFIX,
-  VISIT_UNRESOLVED_POSTFIX,
+  ERROR_UNRESOLVED_POSTFIX,
 
   // TODO(johnniwinther): Add tests for more error cases.
 }