Handle NewExpression in SemanticSendVisitor.

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 '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 10 matching lines @@
   final expression;
   final left;
   final right;
   final type;
   final operator;
   final index;
   final getter;
   final setter;
   final constant;
   final selector;
+  final parameters;
+  final body;
+  final target;
+  final targetType;
+  final initializers;
 
   const Visit(this.method,
               {this.element,
                this.rhs,
                this.arguments,
                this.receiver,
                this.name,
                this.expression,
                this.left,
                this.right,
                this.type,
                this.operator,
                this.index,
                this.getter,
                this.setter,
                this.constant,
-               this.selector});
+               this.selector,
+               this.parameters,
+               this.body,
+               this.target,
+               this.targetType,
+               this.initializers});
 
   int get hashCode => toString().hashCode;
 
   bool operator ==(other) => '$this' == '$other';
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.write('method=$method');
     if (element != null) {
       sb.write(',element=$element');
@@ skipping 33 matching lines @@
     }
     if (setter != null) {
       sb.write(',setter=$setter');
     }
     if (constant != null) {
       sb.write(',constant=$constant');
     }
     if (selector != null) {
       sb.write(',selector=$selector');
     }
+    if (parameters != null) {
+      sb.write(',parameters=$parameters');
+    }
+    if (body != null) {
+      sb.write(',body=$body');
+    }
+    if (target != null) {
+      sb.write(',target=$target');
+    }
+    if (targetType != null) {
+      sb.write(',targetType=$targetType');
+    }
+    if (initializers != null) {
+      sb.write(',initializers=$initializers');
+    }
     return sb.toString();
   }
 }
 
 class Test {
   final String codeByPrefix;
   final String code;
   final /*Visit | List<Visit>*/ expectedVisits;
   final String cls;
+  final String method;
 
   const Test(this.code, this.expectedVisits)
-      : cls = null, codeByPrefix = null;
-  const Test.clazz(this.code, this.expectedVisits)
-      : cls = 'C', codeByPrefix = null;
+      : cls = null, method = 'm', codeByPrefix = null;
+  const Test.clazz(this.code, this.expectedVisits,
+                   {this.cls: 'C', this.method: 'm'})
+      : codeByPrefix = null;
   const Test.prefix(this.codeByPrefix, this.code, this.expectedVisits)
-      : cls = null;
-
-  String get method => 'm';
+      : cls = null, method = 'm';
 
   String toString() {
     StringBuffer sb = new StringBuffer();
     sb.writeln();
     sb.writeln(code);
     if (codeByPrefix != null) {
       sb.writeln('imported by prefix:');
       sb.writeln(codeByPrefix);
     }
     return sb.toString();
   }
 }
 
-const List<Test> TESTS = const [
+const Map<String, List<Test>> SEND_TESTS = const {
+  'Parameters': const [
     // Parameters
     const Test('m(o) => o;',
         const Visit(VisitKind.VISIT_PARAMETER_GET,
                     element: 'parameter(m#o)')),
     const Test('m(o) { o = 42; }',
         const Visit(VisitKind.VISIT_PARAMETER_SET,
                     element: 'parameter(m#o)',
                     rhs:'42')),
     const Test('m(o) { o(null, 42); }',
         const Visit(VisitKind.VISIT_PARAMETER_INVOKE,
                     element: 'parameter(m#o)',
                     arguments: '(null,42)',
                     selector: 'Selector(call, call, arity=2)')),
-
+  ],
+  'Local variables': const [
     // Local variables
     const Test('m() { var o; return o; }',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_GET,
                     element: 'variable(m#o)')),
     const Test('m() { var o; o = 42; }',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_SET,
                     element: 'variable(m#o)',
                     rhs:'42')),
     const Test('m() { var o; o(null, 42); }',
         const Visit(VisitKind.VISIT_LOCAL_VARIABLE_INVOKE,
                     element: 'variable(m#o)',
                     arguments: '(null,42)',
                     selector: 'Selector(call, call, arity=2)')),
-
+  ],
+  'Local functions': const [
     // Local functions
     const Test('m() { o(a, b) {}; return o; }',
         const Visit(VisitKind.VISIT_LOCAL_FUNCTION_GET,
                     element: 'function(m#o)')),
     const Test('m() { o(a, b) {}; o(null, 42); }',
         const Visit(VisitKind.VISIT_LOCAL_FUNCTION_INVOKE,
                     element: 'function(m#o)',
                     arguments: '(null,42)',
                     selector: 'Selector(call, call, arity=2)')),
-
+  ],
+  'Static fields': const [
     // Static fields
     const Test(
         '''
         class C { static var o; }
         m() => C.o;
         ''',
         const Visit(VisitKind.VISIT_STATIC_FIELD_GET,
                     element: 'field(C#o)')),
     const Test.clazz(
         '''
@@ skipping 91 matching lines @@
     const Test.prefix(
         '''
         class C {
           static var o;
         }
         ''',
         'm() { p.C.o(null, 42); }',
         const Visit(VisitKind.VISIT_STATIC_FIELD_INVOKE,
                     element: 'field(C#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Static properties': const [
     // Static properties
     const Test(
         '''
         class C {
           static get o => null;
         }
         m() => C.o;
         ''',
         const Visit(VisitKind.VISIT_STATIC_GETTER_GET,
                     element: 'getter(C#o)')),
@@ skipping 93 matching lines @@
     const Test.prefix(
         '''
         class C {
           static get o => null;
         }
         ''',
         'm() { p.C.o(null, 42); }',
         const Visit(VisitKind.VISIT_STATIC_GETTER_INVOKE,
                     element: 'getter(C#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Static functions': const [
     // Static functions
     const Test(
         '''
         class C { static o(a, b) {} }
         m() => C.o;
         ''',
         const Visit(VisitKind.VISIT_STATIC_FUNCTION_GET,
                     element: 'function(C#o)')),
     const Test.clazz(
         '''
@@ skipping 53 matching lines @@
     const Test.prefix(
         '''
         class C {
           static o(a, b) {}
         }
         ''',
         'm() { p.C.o(null, 42); }',
         const Visit(VisitKind.VISIT_STATIC_FUNCTION_INVOKE,
                     element: 'function(C#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Top level fields': const [
     // Top level fields
     const Test(
         '''
         var o;
         m() => o;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_GET,
                     element: 'field(o)')),
     const Test.prefix(
         '''
@@ skipping 27 matching lines @@
                     element: 'field(o)',
                     arguments: '(null,42)')),
     const Test.prefix(
         '''
         var o;
         ''',
         'm() { p.o(null, 42); }',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FIELD_INVOKE,
                     element: 'field(o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Top level properties': const [
     // Top level properties
     const Test(
         '''
         get o => null;
         m() => o;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_GET,
                     element: 'getter(o)')),
     const Test.prefix(
         '''
@@ skipping 29 matching lines @@
                     element: 'getter(o)',
                     arguments: '(null,42)')),
     const Test.prefix(
         '''
         get o => null;
         ''',
         'm() { p.o(null, 42); }',
         const Visit(VisitKind.VISIT_TOP_LEVEL_GETTER_INVOKE,
                     element: 'getter(o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Top level functions': const [
     // Top level functions
     const Test(
         '''
         o(a, b) {}
         m() => o;
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_GET,
                     element: 'function(o)')),
     const Test(
         '''
         o(a, b) {}
         m() => o(null, 42);
         ''',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_INVOKE,
                     element: 'function(o)',
                     arguments: '(null,42)')),
     const Test.prefix(
         '''
         o(a, b) {}
         ''',
         'm() { p.o(null, 42); }',
         const Visit(VisitKind.VISIT_TOP_LEVEL_FUNCTION_INVOKE,
                     element: 'function(o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Dynamic properties': const [
     // Dynamic properties
     const Test('m(o) => o.foo;',
-        const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_GET,
-                    receiver: 'o',
-                    name: 'foo')),
+        const [
+          const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_GET,
+                      receiver: 'o',
+                      name: 'foo'),
+          const Visit(VisitKind.VISIT_PARAMETER_GET,
+                      element: 'parameter(m#o)'),
+        ]),
     const Test('m(o) { o.foo = 42; }',
-        const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_SET,
-                    receiver: 'o',
-                    name: 'foo',
-                    rhs: '42')),
+        const [
+          const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_SET,
+                      receiver: 'o',
+                      name: 'foo',
+                      rhs: '42'),
+          const Visit(VisitKind.VISIT_PARAMETER_GET,
+                      element: 'parameter(m#o)'),
+        ]),
     const Test('m(o) { o.foo(null, 42); }',
-        const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_INVOKE,
-                    receiver: 'o',
-                    name: 'foo',
-                    arguments: '(null,42)')),
-
+        const [
+          const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_INVOKE,
+                      receiver: 'o',
+                      name: 'foo',
+                      arguments: '(null,42)'),
+          const Visit(VisitKind.VISIT_PARAMETER_GET,
+                      element: 'parameter(m#o)'),
+        ]),
+  ],
+  'This access': const [
     // This access
     const Test.clazz(
         '''
         class C {
           m() => this;
         }
         ''',
         const Visit(VisitKind.VISIT_THIS_GET)),
     const Test.clazz(
         '''
         class C {
           call(a, b) {}
           m() { this(null, 42); }
         }
         ''',
         const Visit(VisitKind.VISIT_THIS_INVOKE,
                     arguments: '(null,42)')),
-
+  ],
+  'This properties': const [
     // This properties
     const Test.clazz(
         '''
         class C {
           var foo;
           m() => foo;
         }
         ''',
         const Visit(VisitKind.VISIT_THIS_PROPERTY_GET,
                     name: 'foo')),
@@ skipping 77 matching lines @@
     const Test.clazz(
         '''
         class C {
           var foo;
           m() { this.foo(null, 42); }
         }
         ''',
         const Visit(VisitKind.VISIT_THIS_PROPERTY_INVOKE,
                     name: 'foo',
                     arguments: '(null,42)')),
-
+  ],
+  'Super fields': const [
     // Super fields
     const Test.clazz(
         '''
         class B {
           var o;
         }
         class C extends B {
           m() => super.o;
         }
         ''',
@@ skipping 16 matching lines @@
         class B {
           var o;
         }
         class C extends B {
           m() { super.o(null, 42); }
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_FIELD_INVOKE,
                     element: 'field(B#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Super properties': const [
     // Super properties
     const Test.clazz(
         '''
         class B {
           get o => null;
         }
         class C extends B {
           m() => super.o;
         }
         ''',
@@ skipping 16 matching lines @@
         class B {
           get o => null;
         }
         class C extends B {
           m() { super.o(null, 42); }
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_GETTER_INVOKE,
                     element: 'getter(B#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Super methods': const [
     // Super methods
     const Test.clazz(
         '''
         class B {
           o(a, b) {}
         }
         class C extends B {
           m() => super.o;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_METHOD_GET,
                     element: 'function(B#o)')),
     const Test.clazz(
         '''
         class B {
           o(a, b) {}
         }
         class C extends B {
           m() { super.o(null, 42); }
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_METHOD_INVOKE,
                     element: 'function(B#o)',
                     arguments: '(null,42)')),
-
+  ],
+  'Expression invoke': const [
     // Expression invoke
     const Test('m() => (a, b){}(null, 42);',
         const Visit(VisitKind.VISIT_EXPRESSION_INVOKE,
                     receiver: '(a,b){}',
                     arguments: '(null,42)')),
-
+  ],
+  'Class type literals': const [
     // Class type literals
     const Test(
         '''
         class C {}
         m() => C;
         ''',
         const Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_GET,
                     constant: 'C')),
     const Test(
         '''
         class C {}
         m() => C(null, 42);
         ''',
         const Visit(VisitKind.VISIT_CLASS_TYPE_LITERAL_INVOKE,
                     constant: 'C',
                     arguments: '(null,42)')),
-
+  ],
+  'Typedef type literals': const [
     // Typedef type literals
     const Test(
         '''
         typedef F();
         m() => F;
         ''',
         const Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_GET,
                     constant: 'F')),
     const Test(
         '''
         typedef F();
         m() => F(null, 42);
         ''',
         const Visit(VisitKind.VISIT_TYPEDEF_TYPE_LITERAL_INVOKE,
                     constant: 'F',
                     arguments: '(null,42)')),
-
+  ],
+  'Type variable type literals': const [
     // Type variable type literals
     const Test.clazz(
         '''
         class C<T> {
           m() => T;
         }
         ''',
         const Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_GET,
                     element: 'type_variable(C#T)')),
     const Test.clazz(
         '''
         class C<T> {
           m() => T(null, 42);
         }
         ''',
         const Visit(VisitKind.VISIT_TYPE_VARIABLE_TYPE_LITERAL_INVOKE,
                     element: 'type_variable(C#T)',
                     arguments: '(null,42)')),
 
+  ],
+  'Dynamic type literals': const [
     // Dynamic type literals
     const Test(
         '''
         m() => dynamic;
         ''',
         const Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_GET,
                     constant: 'dynamic')),
     // TODO(johnniwinther): Enable this when we pass the right constant.
     // Currently we generated the constant for `Type` instead of `dynamic`.
     /*const Test(
         '''
         m() { dynamic(null, 42); }
         ''',
         const Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_INVOKE,
                     constant: 'dynamic',
                     arguments: '(null,42)')),*/
-
+  ],
+  'Assert': const [
     // Assert
     const Test(
         '''
         m() { assert(false); }
         ''',
         const Visit(VisitKind.VISIT_ASSERT, expression: 'false')),
-
+  ],
+  'Logical and': const [
     // Logical and
     const Test(
         '''
         m() => true && false;
         ''',
         const Visit(VisitKind.VISIT_LOGICAL_AND, left: 'true', right: 'false')),
-
+  ],
+  'Logical or': const [
     // Logical or
     const Test(
         '''
         m() => true || false;
         ''',
         const Visit(VisitKind.VISIT_LOGICAL_OR, left: 'true', right: 'false')),
-
+  ],
+  'Is test': const [
     // Is test
     const Test(
         '''
         class C {}
         m() => 0 is C;
         ''',
         const Visit(VisitKind.VISIT_IS, expression: '0', type: 'C')),
-
+  ],
+  'Is not test': const [
     // Is not test
     const Test(
         '''
         class C {}
         m() => 0 is! C;
         ''',
         const Visit(VisitKind.VISIT_IS_NOT, expression: '0', type: 'C')),
-
-    // Is test
+  ],
+  'As test': const [
+    // As test
     const Test(
         '''
         class C {}
         m() => 0 as C;
         ''',
         const Visit(VisitKind.VISIT_AS, expression: '0', type: 'C')),
-
+  ],
+  'Binary operators': const [
     // Binary operators
     const Test(
         '''
         m() => 2 + 3;
         ''',
         const Visit(VisitKind.VISIT_BINARY,
                     left: '2', operator: '+', right: '3')),
     const Test(
         '''
         m() => 2 - 3;
@@ skipping 84 matching lines @@
           operator +(_) => null;
         }
         class C extends B {
           m() => super + 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_BINARY,
                     element: 'function(B#+)',
                     operator: '+',
                     right: '42')),
+  ],
+  'Index': const [
     // Index
     const Test(
         '''
         m() => 2[3];
         ''',
         const Visit(VisitKind.VISIT_INDEX,
                     receiver: '2', index: '3')),
     const Test(
         '''
         m() => --2[3];
@@ skipping 41 matching lines @@
         }
         class C extends B {
           m() => super[42]--;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_INDEX_POSTFIX,
                     getter: 'function(B#[])',
                     setter: 'function(B#[]=)',
                     index: '42',
                     operator: '--')),
-
+  ],
+  'Equals': const [
     // Equals
     const Test(
         '''
         m() => 2 == 3;
         ''',
         const Visit(VisitKind.VISIT_EQUALS,
                     left: '2', right: '3')),
     const Test.clazz(
         '''
         class B {
           operator ==(_) => null;
         }
         class C extends B {
           m() => super == 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_EQUALS,
                     element: 'function(B#==)',
                     right: '42')),
-
+  ],
+  'Not equals': const [
     // Not equals
     const Test(
         '''
         m() => 2 != 3;
         ''',
         const Visit(VisitKind.VISIT_NOT_EQUALS,
                     left: '2', right: '3')),
     // TODO(johnniwinther): Enable this. Resolution does not store the element.
     /*const Test.clazz(
         '''
         class B {
           operator ==(_) => null;
         }
         class C extends B {
           m() => super != 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_NOT_EQUALS,
                     element: 'function(B#==)',
                     right: '42')),*/
-
+  ],
+  'Unary expression': const [
     // Unary expression
     const Test(
         '''
         m() => -false;
         ''',
         const Visit(VisitKind.VISIT_UNARY,
                     expression: 'false', operator: '-')),
     const Test(
         '''
         m() => ~false;
@@ skipping 20 matching lines @@
           m() => ~super;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_UNARY,
                     element: 'function(B#~)', operator: '~')),
     const Test(
         '''
         m() => !0;
         ''',
         const Visit(VisitKind.VISIT_NOT, expression: '0')),
-
+  ],
+  'Index set': const [
     // Index set
     const Test(
         '''
         m() => 0[1] = 2;
         ''',
         const Visit(VisitKind.VISIT_INDEX_SET,
             receiver: '0', index: '1', rhs: '2')),
     const Test.clazz(
         '''
         class B {
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[1] = 2;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_INDEX_SET,
             element: 'function(B#[]=)', index: '1', rhs: '2')),
-
+  ],
+  'Compound assignment': const [
     // Compound assignment
     const Test(
         '''
         m(a) => a.b += 42;
         ''',
         const [
           const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_COMPOUND,
               receiver: 'a', operator: '+=', rhs: '42',
               getter: 'Selector(getter, b, arity=0)',
               setter: 'Selector(setter, b, arity=1)'),
@@ skipping 297 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')),*/
-
+  ],
+  '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')),
     // TODO(johnniwinther): Enable this when the getter element is stored.
     /*const Test.clazz(
         '''
         class B {
           operator [](_) {}
           operator []=(a, b) {}
         }
         class C extends B {
           m() => super[1] += 42;
         }
         ''',
         const Visit(VisitKind.VISIT_SUPER_COMPOUND_INDEX_SET,
             getter: 'function(B#[])', setter: 'function(B#[]=)',
             index: '1', operator: '+=', rhs: '42')),*/
-
+  ],
+  'Prefix expression': const [
     // Prefix expression
     const Test(
         '''
         m(a) => --a.b;
         ''',
         const [
           const Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_PREFIX,
               receiver: 'a', operator: '--',
               getter: 'Selector(getter, b, arity=0)',
               setter: 'Selector(setter, b, arity=1)'),
@@ skipping 201 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: '++')),
-
-    // Prefix expression
+  ],
+  '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,
@@ skipping 200 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: '++')),
-
-];
-
-main() {
+  ],
+  'Constructor invocations': const [
+    const Test(
+        '''
+        class Class {
+          const Class(a, b);
+        }
+        m() => const Class(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_CONST_CONSTRUCTOR_INVOKE,
+            constant: 'const Class(true, 42)')),
+    const Test(
+        '''
+        class Class {}
+        m() => new Class();
+        ''',
+        const Visit(VisitKind.VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
+            element: 'generative_constructor(Class#)',
+            arguments: '()',
+            type: 'Class',
+            selector: 'Selector(call, , arity=0)')),
+    const Test(
+        '''
+        class Class {
+          Class(a, b);
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
+            element: 'generative_constructor(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class {
+          Class.named(a, b);
+        }
+        m() => new Class.named(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
+            element: 'generative_constructor(Class#named)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, named, arity=2)')),
+    const Test(
+        '''
+        class Class {
+          Class(a, b) : this._(a, b);
+          Class._(a, b);
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_REDIRECTING_GENERATIVE_CONSTRUCTOR_INVOKE,
+            element: 'generative_constructor(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class {
+          factory Class(a, b) => new Class._(a, b);
+          Class._(a, b);
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class<T> {
+          factory Class(a, b) = Class<int>.a;
+          factory Class.a(a, b) = Class<Class<T>>.b;
+          Class.b(a, b);
+        }
+        m() => new Class<double>(true, 42);
+        ''',
+        const Visit(VisitKind.VISIT_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class<double>',
+            target: 'generative_constructor(Class#b)',
+            targetType: 'Class<Class<int>>',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class {
+          Class(a, b);
+        }
+        m() => new Class.unresolved(true, 42);
+        ''',
+        const Visit(
+            VisitKind.ERROR_UNRESOLVED_CONSTRUCTOR_INVOKE,
+            arguments: '(true,42)')),
+    const Test(
+        '''
+        m() => new Unresolved(true, 42);
+        ''',
+        const Visit(
+            // TODO(johnniwinther): Update this to
+            // `VisitKind.ERROR_UNRESOLVED_CLASS_CONSTRUCTOR_INVOKE`.
+            VisitKind.ERROR_UNRESOLVED_CONSTRUCTOR_INVOKE,
+            arguments: '(true,42)')),
+    const Test(
+        '''
+        abstract class AbstractClass {}
+        m() => new AbstractClass();
+        ''',
+        const Visit(
+            VisitKind.ERROR_ABSTRACT_CLASS_CONSTRUCTOR_INVOKE,
+            element: 'generative_constructor(AbstractClass#)',
+            type: 'AbstractClass',
+            arguments: '()',
+            selector: 'Selector(call, , arity=0)')),
+    const Test(
+        '''
+        class Class {
+          factory Class(a, b) = Unresolved;
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(
+            VisitKind.ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class {
+          factory Class(a, b) = Class.named;
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(
+            VisitKind.ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        class Class {
+          factory Class(a, b) = Class.named;
+          factory Class.named(a, b) = Class.unresolved;
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(
+            VisitKind.ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+    const Test(
+        '''
+        abstract class AbstractClass {
+          AbstractClass(a, b);
+        }
+        class Class {
+          factory Class(a, b) = AbstractClass;
+        }
+        m() => new Class(true, 42);
+        ''',
+        const Visit(
+            VisitKind.ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+            element: 'function(Class#)',
+            arguments: '(true,42)',
+            type: 'Class',
+            selector: 'Selector(call, , arity=2)')),
+  ],
+};
+
+main(List<String> arguments) {
+  asyncTest(() => Future.forEach([
+    () {
+      return test(
+          arguments,
+          SEND_TESTS,
+          (elements) => new SemanticSendTestVisitor(elements));
+    },
+  ], (f) => f()));
+}
+
+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((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++;
+  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();
 
-  asyncTest(() {
-    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;
-        if (expectedVisits is! List) {
-          expectedVisits = [expectedVisits];
-        }
-        AstElement element;
-        String cls = test.cls;
-        String method = test.method;
-        if (cls == null) {
-          element = library.find(method);
-        } else {
-          ClassElement classElement = library.find(cls);
-          Expect.isNotNull(classElement,
-                           "Class '$cls' not found in:\n"
-                           "${library.compilationUnit.script.text}");
-          element = classElement.localLookup(method);
-        }
-        Expect.isNotNull(element, "Element '$method' not found in:\n"
-                                  "${library.compilationUnit.script.text}");
-        ResolvedAst resolvedAst = element.resolvedAst;
-        SemanticTestVisitor visitor =
-            new SemanticTestVisitor(resolvedAst.elements);
-        try {
-          compiler.withCurrentElement(resolvedAst.element, () {
-            //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}");
-      });
+  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;
+      if (expectedVisits is! List) {
+        expectedVisits = [expectedVisits];
+      }
+      AstElement element;
+      String cls = test.cls;
+      String method = test.method;
+      if (cls == null) {
+        element = library.find(method);
+      } else {
+        ClassElement classElement = library.find(cls);
+        Expect.isNotNull(classElement,
+                         "Class '$cls' not found in:\n"
+                         "${library.compilationUnit.script.text}");
+        element = classElement.localLookup(method);
+      }
+      Expect.isNotNull(element, "Element '$method' not found in:\n"
+                                "${library.compilationUnit.script.text}");
+      ResolvedAst resolvedAst = element.resolvedAst;
+      SemanticTestVisitor visitor = createVisitor(resolvedAst.elements);
+      try {
+        compiler.withCurrentElement(resolvedAst.element, () {
+          //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}");
     });
   });
 }
 
 
-class SemanticTestVisitor extends SemanticVisitor with SemanticSendVisitor {
+abstract class SemanticTestVisitor extends TraversalVisitor {
   List<Visit> visits = <Visit>[];
 
   SemanticTestVisitor(TreeElements elements) : super(elements);
 
   apply(Node node, arg) => node.accept(this);
 
   internalError(Spannable spannable, String message) {
     throw new SpannableAssertionFailure(spannable, message);
   }
+}
 
-  SemanticSendVisitor get sendVisitor => this;
+class SemanticSendTestVisitor extends SemanticTestVisitor {
 
-  @override
-  visitNode(Node node) {
-    node.visitChildren(this);
-  }
+  SemanticSendTestVisitor(TreeElements elements) : super(elements);
 
   @override
   visitAs(
       Send node,
       Node expression,
       DartType type,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_AS,
         expression: expression, type: type));
     apply(expression, arg);
@@ skipping 114 matching lines @@
   }
 
   @override
   visitDynamicPropertyGet(
       Send node,
       Node receiver,
       Selector selector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_GET,
         receiver: receiver, name: selector.name));
+    apply(receiver, arg);
   }
 
   @override
   visitDynamicPropertyInvoke(
       Send node,
       Node receiver,
       NodeList arguments,
       Selector selector,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_INVOKE,
         receiver: receiver, name: selector.name, arguments: arguments));
+    apply(receiver, arg);
     apply(arguments, arg);
   }
 
   @override
   visitDynamicPropertySet(
       SendSet node,
       Node receiver,
       Selector selector,
       Node rhs,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_DYNAMIC_PROPERTY_SET,
         receiver: receiver, name: selector.name, rhs: rhs));
+    apply(receiver, arg);
   }
 
   @override
   visitDynamicTypeLiteralGet(
       Send node,
       ConstantExpression constant,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_DYNAMIC_TYPE_LITERAL_GET,
         constant: constant.getText()));
   }
@@ skipping 1750 matching lines @@
       FunctionElement indexFunction,
       FunctionElement indexSetFunction,
       Node index,
       IncDecOperator operator,
       arg) {
     visits.add(new Visit(VisitKind.VISIT_SUPER_INDEX_PREFIX,
         getter: indexFunction, setter: indexSetFunction,
         index: index, operator: operator));
     apply(index, arg);
   }
+
+  @override
+  errorUnresolvedClassConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      MalformedType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    // TODO(johnniwinther): Test [type] and [selector].
+    visits.add(new Visit(
+        VisitKind.ERROR_UNRESOLVED_CLASS_CONSTRUCTOR_INVOKE,
+        arguments: arguments));
+    apply(arguments, arg);
+  }
+
+  @override
+  errorUnresolvedConstructorInvoke(
+      NewExpression node,
+      Element constructor,
+      DartType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    // TODO(johnniwinther): Test [type] and [selector].
+    visits.add(new Visit(
+        VisitKind.ERROR_UNRESOLVED_CONSTRUCTOR_INVOKE,
+        arguments: arguments));
+    apply(arguments, arg);
+  }
+
+  @override
+  visitConstConstructorInvoke(
+      NewExpression node,
+      ConstructedConstantExpression constant,
+      arg) {
+    visits.add(new Visit(VisitKind.VISIT_CONST_CONSTRUCTOR_INVOKE,
+                         constant: constant.getText()));
+  }
+
+  @override
+  visitFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.VISIT_FACTORY_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
+
+  @override
+  visitGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.VISIT_GENERATIVE_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
+
+  @override
+  visitRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      ConstructorElement effectiveTarget,
+      InterfaceType effectiveTargetType,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.VISIT_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        target: effectiveTarget,
+        targetType: effectiveTargetType,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
+
+  @override
+  visitRedirectingGenerativeConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.VISIT_REDIRECTING_GENERATIVE_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
+
+  @override
+  errorAbstractClassConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.ERROR_ABSTRACT_CLASS_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
+
+  @override
+  errorUnresolvedRedirectingFactoryConstructorInvoke(
+      NewExpression node,
+      ConstructorElement constructor,
+      InterfaceType type,
+      NodeList arguments,
+      Selector selector,
+      arg) {
+    visits.add(new Visit(
+        VisitKind.ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+        element: constructor,
+        type: type,
+        arguments: arguments,
+        selector: selector));
+    apply(arguments, arg);
+  }
 }
 
 enum VisitKind {
   VISIT_PARAMETER_GET,
   VISIT_PARAMETER_SET,
   VISIT_PARAMETER_INVOKE,
   VISIT_PARAMETER_COMPOUND,
   VISIT_PARAMETER_PREFIX,
   VISIT_PARAMETER_POSTFIX,
 
@@ skipping 139 matching lines @@
   VISIT_SUPER_INDEX_SET,
   VISIT_SUPER_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,
+
+  ERROR_UNRESOLVED_CLASS_CONSTRUCTOR_INVOKE,
+  ERROR_UNRESOLVED_CONSTRUCTOR_INVOKE,
+  ERROR_ABSTRACT_CLASS_CONSTRUCTOR_INVOKE,
+  ERROR_UNRESOLVED_REDIRECTING_FACTORY_CONSTRUCTOR_INVOKE,
+
   // TODO(johnniwinther): Add tests for error cases.
 }