Move more messages.

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 'dart:async';
 import 'dart:collection';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 840 matching lines @@
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { Enum e = Enum.B; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(1, collector.warnings.length,
                     'Unexpected warnings: ${collector.warnings}');
-      Expect.equals(MessageKind.MEMBER_NOT_FOUND,
+      Expect.equals(MessageKind.UNDEFINED_GETTER,
                     collector.warnings.first.message.kind);
       Expect.equals(0, collector.errors.length,
                     'Unexpected errors: ${collector.errors}');
     }),
 
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""enum Enum { A }
                               main() { List values = Enum.values; }""");
       FunctionElement mainElement = compiler.mainApp.find(MAIN);
       compiler.resolver.resolve(mainElement);
@@ skipping 386 matching lines @@
 
   // Can't override instance methods
   checkWarningOn('''
       main() { new B().bar(); }
       class B {
         mname() {}
         bar() {
           mname = () => null;
         }
       }
-      ''', [MessageKind.SETTER_NOT_FOUND]);
+      ''', [MessageKind.UNDEFINED_SETTER]);
   checkWarningOn('''
       main() { new B().bar(); }
       class B {
         mname() {}
         bar() {
           this.mname = () => null;
         }
       }
-      ''', [MessageKind.SETTER_NOT_FOUND]);
+      ''', [MessageKind.UNDEFINED_SETTER]);
 
   // Can't override super methods
   checkWarningOn('''
       main() { new B().bar(); }
       class A {
         mname() {}
       }
       class B extends A {
         bar() {
           super.mname = () => 6;
         }
       }
       ''', [MessageKind.ASSIGNING_METHOD_IN_SUPER,
             // TODO(johnniwinther): Avoid duplicate warnings.
-            MessageKind.SETTER_NOT_FOUND]);
+            MessageKind.UNDEFINED_SETTER]);
 
   // But index operators should be OK
   checkWarningOn('''
       main() { new B().bar(); }
       class B {
         operator[]=(x, y) {}
         bar() {
           this[1] = 3; // This is OK
         }
       }
@@ skipping 11 matching lines @@
       ''', []);
 }
 
 testCantAssignFinalAndConsts() {
   // Can't write final or const locals.
   checkWarningOn('''
       main() {
         final x = 1;
         x = 2;
       }
-      ''', [MessageKind.CANNOT_RESOLVE_SETTER]);
+      ''', [MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER]);
   checkWarningOn('''
       main() {
         const x = 1;
         x = 2;
       }
-      ''', [MessageKind.CANNOT_RESOLVE_SETTER]);
+      ''', [MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER]);
   checkWarningOn('''
       final x = 1;
       main() { x = 3; }
-      ''', [MessageKind.CANNOT_RESOLVE_SETTER]);
+      ''', [MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER]);
 
   checkWarningOn('''
       const x = 1;
       main() { x = 3; }
-      ''', [MessageKind.CANNOT_RESOLVE_SETTER]);
+      ''', [MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER]);
 
   // Detect assignments to final fields:
   checkWarningOn('''
       main() => new B().m();
       class B {
         final x = 1;
         m() { x = 2; }
       }
-      ''', [MessageKind.SETTER_NOT_FOUND]);
+      ''', [MessageKind.UNDEFINED_SETTER]);
 
   // ... even if 'this' is explicit:
   checkWarningOn('''
       main() => new B().m();
       class B {
         final x = 1;
         m() { this.x = 2; }
       }
-      ''', [MessageKind.SETTER_NOT_FOUND]);
+      ''', [MessageKind.UNDEFINED_SETTER]);
 
   // ... and in super class:
   checkWarningOn('''
       main() => new B().m();
       class A {
         final x = 1;
       }
       class B extends A {
         m() { super.x = 2; }
       }
       ''', [MessageKind.ASSIGNING_FINAL_FIELD_IN_SUPER,
             // TODO(johnniwinther): Avoid duplicate warnings.
-            MessageKind.SETTER_NOT_FOUND]);
+            MessageKind.UNDEFINED_SETTER]);
 
   // But non-final fields are OK:
   checkWarningOn('''
       main() => new B().m();
       class A {
         int x = 1;
       }
       class B extends A {
         m() { super.x = 2; }
       }
       ''', []);
 
   // Check getter without setter.
   checkWarningOn('''
       main() => new B().m();
       class A {
         get x => 1;
       }
       class B extends A {
         m() { super.x = 2; }
       }
-      ''', [MessageKind.SETTER_NOT_FOUND_IN_SUPER,
+      ''', [MessageKind.UNDEFINED_SUPER_SETTER,
             // TODO(johnniwinther): Avoid duplicate warnings.
-            MessageKind.SETTER_NOT_FOUND]);
+            MessageKind.UNDEFINED_SETTER]);
 }
 
 /// Helper to test that [script] produces all the given [warnings].
 checkWarningOn(String script, List<MessageKind> warnings) {
   Expect.isTrue(warnings.length >= 0 && warnings.length <= 2);
   asyncTest(() => compileScript(script).then((compiler) {
     DiagnosticCollector collector = compiler.diagnosticCollector;
     Expect.equals(0, collector.errors.length,
         'Unexpected errors in\n$script\n${collector.errors}');
     Expect.equals(warnings.length, collector.warnings.length,
@@ skipping 36 matching lines @@
     }
     main() => A.m();
   ''', functionName: 'm');
   check('''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''', className: 'A');
 }