Typecheck constructor calls. I'm pretty sure about the call to

frog/tests/leg/src/TypeCheckerTest.dart

 // Copyright (c) 2011, 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.
 
 #import("../../../../lib/compiler/implementation/leg.dart");
 #import("../../../../lib/compiler/implementation/elements/elements.dart");
 #import("../../../../lib/compiler/implementation/tree/tree.dart");
 #import('../../../../lib/compiler/implementation/scanner/scannerlib.dart');
 #import("../../../../lib/compiler/implementation/util/util.dart");
 #import("mock_compiler.dart");
 #import("parser_helper.dart");
 
 Type intType;
 Type boolType;
 Type stringType;
 Type doubleType;
 Type objectType;
 
 main() {
   List tests = [testSimpleTypes,
                 testReturn,
                 testFor,
                 testWhile,
                 testOperators,
+                testConstructorInvocationArgumentCount,
+                testConstructorInvocationArgumentTypes,
                 testMethodInvocationArgumentCount,
                 testMethodInvocations,
                 testControlFlow,
                 // testNewExpression,
                 testConditionalExpression,
                 testIfStatement,
                 testThis,
                 testFunctionSubtyping];
   for (Function test in tests) {
     setup();
@@ skipping 90 matching lines @@
   for (final op in ['>', '<', '<=', '>=', '==', '!=', '===', '!==']) {
     analyze("{ bool b = 1 ${op} 2; }");
     analyze("{ int i = 1 ${op} 2; }", MessageKind.NOT_ASSIGNABLE);
     analyze("{ int i; bool b = (i = true) ${op} 2; }",
             MessageKind.NOT_ASSIGNABLE);
     analyze("{ int i; bool b = 1 ${op} (i = true); }",
             MessageKind.NOT_ASSIGNABLE);
   }
 }
 
+void testConstructorInvocationArgumentCount() {
+  compiler.parseScript("""
+     class C1 { C1(x, y); }
+     class C2 { C2(int x, int y); }
+  """);
+  // calls to untyped constructor C1
+  analyze("new C1(1, 2);");
+  analyze("new C1();", MessageKind.MISSING_ARGUMENT);
+  analyze("new C1(1);", MessageKind.MISSING_ARGUMENT);
+  analyze("new C1(1, 2, 3);", MessageKind.ADDITIONAL_ARGUMENT);
+  // calls to typed constructor C2
+  analyze("new C2(1, 2);");
+  analyze("new C2();", MessageKind.MISSING_ARGUMENT);
+  analyze("new C2(1);", MessageKind.MISSING_ARGUMENT);
+  analyze("new C2(1, 2, 3);", MessageKind.ADDITIONAL_ARGUMENT);
+}
+
+void testConstructorInvocationArgumentTypes() {
+  compiler.parseScript("""
+    class C1 { C1(x); }
+    class C2 { C2(int x); }
+  """);
+  analyze("new C1(42);");
+  analyze("new C1('string');");
+  analyze("new C2(42);");
+  analyze("new C2('string');",
+          MessageKind.NOT_ASSIGNABLE);
+}
+
 void testMethodInvocationArgumentCount() {
   compiler.parseScript(CLASS_WITH_METHODS);
   final String header = "{ ClassWithMethods c; ";
   analyze("${header}c.untypedNoArgumentMethod(1); }",
           MessageKind.ADDITIONAL_ARGUMENT);
   analyze("${header}c.untypedOneArgumentMethod(); }",
           MessageKind.MISSING_ARGUMENT);
   analyze("${header}c.untypedOneArgumentMethod(1, 1); }",
           MessageKind.ADDITIONAL_ARGUMENT);
   analyze("${header}c.untypedTwoArgumentMethod(); }",
@@ skipping 47 matching lines @@
           MessageKind.NOT_ASSIGNABLE);
   analyze("${header}int k = c.intOneArgumentMethod('string'); }",
           MessageKind.NOT_ASSIGNABLE);
   analyze("${header}int k = c.intOneArgumentMethod(i); }");
 
   analyze("${header}int k = c.intTwoArgumentMethod(1, 'string'); }",
           MessageKind.NOT_ASSIGNABLE);
   analyze("${header}int k = c.intTwoArgumentMethod(i, j); }");
   analyze("${header}ClassWithMethods x = c.intTwoArgumentMethod(i, j); }",
           MessageKind.NOT_ASSIGNABLE);
+
+  analyze("${header}c.intField(); }", MessageKind.METHOD_NOT_FOUND);
+  analyze("${header}d.intField(); }", MessageKind.METHOD_NOT_FOUND);
 }
 
 /** Tests analysis of returns (not required by the specification). */
 void testControlFlow() {
   analyzeTopLevel("int foo() { if (true) { return 1; } }",
                   MessageKind.MAYBE_MISSING_RETURN);
   final bar =
       """void bar() {
         if (true) {
           if (true) { return; } else { return; }
@@ skipping 211 matching lines @@
   parser.parseStatement(tokens);
   Node node = listener.popNode();
   TreeElements elements = compiler.resolveNodeStatement(node, classElement);
   TypeCheckerVisitor checker = new TypeCheckerVisitor(compiler, elements,
                                                                 types);
   compiler.clearWarnings();
   checker.currentClass = classElement;
   checker.analyze(node);
   compareWarningKinds(text, expectedWarnings, compiler.warnings);
 }