Check for non-final field in the face of const constructors.

tests/compiler/dart2js/resolver_test.dart

 // Copyright (c) 2012, 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 "package:expect/expect.dart";
 import 'dart:async';
 import "package:async_helper/async_helper.dart";
 import 'dart:collection';
 
 import "../../../sdk/lib/_internal/compiler/implementation/resolution/resolution.dart";
@@ skipping 61 matching lines @@
   testInitializers();
   testThis();
   testSuperCalls();
   testTypeVariables();
   testToString();
   testIndexedOperator();
   testIncrementsAndDecrements();
   testOverrideHashCodeCheck();
   testSupertypeOrder();
   testConstructorArgumentMismatch();
+  testConstConstructorAndNonFinalFields();
 }
 
 testSupertypeOrder() {
   MockCompiler compiler = new MockCompiler();
   compiler.parseScript("""
 class I1 {}
 class I2 {}
 class J1 extends K1 {}
 class J2 implements K2 {}
 class K1 {}
@@ skipping 747 matching lines @@
 List<String> asSortedStrings(Link link) {
   List<String> result = <String>[];
   for (; !link.isEmpty; link = link.tail) result.add(link.head.toString());
   result.sort((s1, s2) => s1.compareTo(s2));
   return result;
 }
 
 Future compileScript(String source) {
   Uri uri = new Uri(scheme: 'source');
   MockCompiler compiler = compilerFor(source, uri);
+  compiler.diagnosticHandler = createHandler(compiler, source);
   return compiler.runCompiler(uri).then((_) {
     return compiler;
   });
 }
 
 checkMemberResolved(compiler, className, memberName) {
   ClassElement cls = findElement(compiler, className);
   Element memberElement = cls.lookupLocalMember(memberName);
   Expect.isNotNull(memberElement);
   Expect.isNotNull(
@@ skipping 60 matching lines @@
       main() {
         new A() == new B();
       }""";
   asyncTest(() => compileScript(script).then((compiler) {
     Expect.equals(1, compiler.warnings.length);
     Expect.equals(MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
                   compiler.warnings[0].message.kind);
     Expect.equals(0, compiler.errors.length);
   }));
 }
+
+testConstConstructorAndNonFinalFields() {
+  void expect(compiler, List errors, List warnings) {
+    Expect.equals(errors.length, compiler.errors.length);
+    for (int i = 0 ; i < errors.length ; i++) {
+      Expect.equals(errors[i], compiler.errors[i].message.kind);
+    }
+    Expect.equals(warnings.length, compiler.warnings.length);
+    for (int i = 0 ; i < warnings.length ; i++) {
+      Expect.equals(warnings[i], compiler.warnings[i].message.kind);
+    }
+  }
+
+  final script1 = r"""
+      class A {
+        var a;
+        const A(this.a);
+      }
+      main() {
+        new A(0);
+      }""";
+  asyncTest(() => compileScript(script1).then((compiler) {
+    expect(compiler,
+           [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
+           [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
+  }));
+
+  final script2 = r"""
+      class A {
+        var a;
+        var b;
+        const A(this.a, this.b);
+        const A.named(this.a, this.b);
+      }
+      main() {
+        new A(0, 1);
+      }""";
+  asyncTest(() => compileScript(script2).then((compiler) {
+    expect(compiler,
+        [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS],
+        [MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
+         MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_CONSTRUCTOR,
+         MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD,
+         MessageKind.CONST_CONSTRUCTOR_WITH_NONFINAL_FIELDS_FIELD]);
+  }));
+}