Move more messages.

tests/compiler/dart2js/type_checker_test.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 'dart:async';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 
 import 'package:compiler/src/dart_types.dart';
@@ skipping 11 matching lines @@
 import 'package:compiler/src/parser/element_listener.dart';
 import 'package:compiler/src/tree/tree.dart';
 import 'package:compiler/src/typechecker.dart';
 import 'package:compiler/src/script.dart';
 import 'package:compiler/src/util/util.dart';
 
 import 'mock_compiler.dart';
 import 'parser_helper.dart';
 
 final MessageKind NOT_ASSIGNABLE = MessageKind.NOT_ASSIGNABLE;
-final MessageKind MEMBER_NOT_FOUND = MessageKind.MEMBER_NOT_FOUND;
+final MessageKind UNDEFINED_GETTER = MessageKind.UNDEFINED_GETTER;
 
 main() {
   List tests = [testSimpleTypes,
                 testReturn,
                 testFor,
                 testSyncForIn,
                 testAsyncForIn,
                 testWhile,
                 testTry,
                 testSwitch,
@@ skipping 76 matching lines @@
   check("for (;null;) {}");
   check("for (;0;) {}", warnings: NOT_ASSIGNABLE);
   check("for (;'';) {}", warnings: NOT_ASSIGNABLE);
 
   // Foreach tests
 //  TODO(karlklose): for each is not yet implemented.
 //  check("{ List<String> strings = ['1','2','3']; " +
 //        "for (String s in strings) {} }");
 //  check("{ List<int> ints = [1,2,3]; for (String s in ints) {} }",
 //        NOT_ASSIGNABLE);
-//  check("for (String s in true) {}", MessageKind.METHOD_NOT_FOUND);
+//  check("for (String s in true) {}", MessageKind.UNDEFINED_METHOD);
 }
 
 
 testSyncForIn(MockCompiler compiler) {
   String script = """
 class HasUntypedIterator {
   get iterator => null;
 }
 
 class HasIntIterator {
@@ skipping 67 matching lines @@
   }""");
   analyzeIn(compiler, method, """{ 
       for (String e in new HasIntIterator()) {} 
   }""", hints: MessageKind.FORIN_NOT_ASSIGNABLE);
   analyzeIn(compiler, method, """{ 
       for (int e in new HasIntIterator()) {} 
   }""");
 
   analyzeIn(compiler, method, """{ 
       for (var e in new HasNoIterator()) {} 
-  }""", warnings: MessageKind.MEMBER_NOT_FOUND);
+  }""", warnings: MessageKind.UNDEFINED_GETTER);
   analyzeIn(compiler, method, """{ 
       for (String e in new HasNoIterator()) {} 
-  }""", warnings: MessageKind.MEMBER_NOT_FOUND);
+  }""", warnings: MessageKind.UNDEFINED_GETTER);
   analyzeIn(compiler, method, """{ 
       for (int e in new HasNoIterator()) {} 
-  }""", warnings: MessageKind.MEMBER_NOT_FOUND);
+  }""", warnings: MessageKind.UNDEFINED_GETTER);
 
   analyzeIn(compiler, method, """{ 
       for (var e in new HasCustomIntIterator()) {} 
   }""");
   analyzeIn(compiler, method, """{ 
       for (String e in new HasCustomIntIterator()) {} 
   }""", hints: MessageKind.FORIN_NOT_ASSIGNABLE);
   analyzeIn(compiler, method, """{ 
       for (int e in new HasCustomIntIterator()) {} 
   }""");
 
   analyzeIn(compiler, method, """{ 
       for (var e in new HasCustomNoCurrentIterator()) {} 
-  }""", hints: MessageKind.MEMBER_NOT_FOUND);
+  }""", hints: MessageKind.UNDEFINED_GETTER);
   analyzeIn(compiler, method, """{ 
       for (String e in new HasCustomNoCurrentIterator()) {} 
-  }""", hints: MessageKind.MEMBER_NOT_FOUND);
+  }""", hints: MessageKind.UNDEFINED_GETTER);
   analyzeIn(compiler, method, """{ 
       for (int e in new HasCustomNoCurrentIterator()) {} 
-  }""", hints: MessageKind.MEMBER_NOT_FOUND);
+  }""", hints: MessageKind.UNDEFINED_GETTER);
 
   analyzeIn(compiler, method, """{ 
       var localDyn; 
       for (localDyn in <String>[]) {} 
   }""");
   analyzeIn(compiler, method, """{ 
       String localString; 
       for (localString in <String>[]) {} 
   }""");
   analyzeIn(compiler, method, """{ 
@@ skipping 312 matching lines @@
   check(String code, {warnings}) {
     analyze(compiler, code, warnings: warnings);
   }
 
   // TODO(karlklose): add the DartC tests for operators when we can parse
   // classes with operators.
   for (final op in ['+', '-', '*', '/', '%', '~/', '|', '&']) {
     check("{ var i = 1 ${op} 2; }");
     check("{ var i = 1; i ${op}= 2; }");
     check("{ int i; var j = (i = true) ${op} 2; }",
-          warnings: [NOT_ASSIGNABLE, MessageKind.OPERATOR_NOT_FOUND]);
+          warnings: [NOT_ASSIGNABLE, MessageKind.UNDEFINED_OPERATOR]);
     check("{ int i; var j = 1 ${op} (i = true); }",
           warnings: [NOT_ASSIGNABLE, NOT_ASSIGNABLE]);
   }
   for (final op in ['-', '~']) {
     check("{ var i = ${op}1; }");
     check("{ int i; var j = ${op}(i = true); }",
-          warnings: [NOT_ASSIGNABLE, MessageKind.OPERATOR_NOT_FOUND]);
+          warnings: [NOT_ASSIGNABLE, MessageKind.UNDEFINED_OPERATOR]);
   }
   for (final op in ['++', '--']) {
     check("{ int i = 1; int j = i${op}; }");
     check("{ int i = 1; bool j = i${op}; }", warnings: NOT_ASSIGNABLE);
     check("{ bool b = true; bool j = b${op}; }",
-          warnings: MessageKind.OPERATOR_NOT_FOUND);
+          warnings: MessageKind.UNDEFINED_OPERATOR);
     check("{ bool b = true; int j = ${op}b; }",
-          warnings: MessageKind.OPERATOR_NOT_FOUND);
+          warnings: MessageKind.UNDEFINED_OPERATOR);
   }
   for (final op in ['||', '&&']) {
     check("{ bool b = (true ${op} false); }");
     check("{ int b = true ${op} false; }", warnings: NOT_ASSIGNABLE);
     check("{ bool b = (1 ${op} false); }", warnings: NOT_ASSIGNABLE);
     check("{ bool b = (true ${op} 2); }", warnings: NOT_ASSIGNABLE);
   }
   for (final op in ['>', '<', '<=', '>=']) {
     check("{ bool b = 1 ${op} 2; }");
     check("{ int i = 1 ${op} 2; }", warnings: NOT_ASSIGNABLE);
     check("{ int i; bool b = (i = true) ${op} 2; }",
-          warnings: [NOT_ASSIGNABLE, MessageKind.OPERATOR_NOT_FOUND]);
+          warnings: [NOT_ASSIGNABLE, MessageKind.UNDEFINED_OPERATOR]);
     check("{ int i; bool b = 1 ${op} (i = true); }",
           warnings: [NOT_ASSIGNABLE, NOT_ASSIGNABLE]);
   }
   for (final op in ['==', '!=']) {
     check("{ bool b = 1 ${op} 2; }");
     check("{ int i = 1 ${op} 2; }", warnings: NOT_ASSIGNABLE);
     check("{ int i; bool b = (i = true) ${op} 2; }",
           warnings: NOT_ASSIGNABLE);
     check("{ int i; bool b = 1 ${op} (i = true); }",
           warnings: NOT_ASSIGNABLE);
@@ skipping 384 matching lines @@
     check(c, "localMethod();", MessageKind.MISSING_ARGUMENT);
     check(c, "localMethod(1);", NOT_ASSIGNABLE);
     check(c, "localMethod('string');");
     check(c, "int k = localMethod('string');");
     check(c, "String k = localMethod('string');", NOT_ASSIGNABLE);
 
     // Invocation on parenthesized expressions.
     check(c, "(e)();");
     check(c, "(e)(1);");
     check(c, "(e)('string');");
-    check(c, "(foo)();", MEMBER_NOT_FOUND);
-    check(c, "(foo)(1);", MEMBER_NOT_FOUND);
-    check(c, "(foo)('string');", MEMBER_NOT_FOUND);
+    check(c, "(foo)();", UNDEFINED_GETTER);
+    check(c, "(foo)(1);", UNDEFINED_GETTER);
+    check(c, "(foo)('string');", UNDEFINED_GETTER);
 
     // Invocations on function expressions.
     check(c, "(foo){}();", MessageKind.MISSING_ARGUMENT);
     check(c, "(foo){}(1);");
     check(c, "(foo){}('string');");
     check(c, "(int foo){}('string');", NOT_ASSIGNABLE);
     check(c, "(String foo){}('string');");
     check(c, "int k = int bar(String foo){ return 0; }('string');");
     check(c, "int k = String bar(String foo){ return foo; }('string');",
           NOT_ASSIGNABLE);
 
     // Static invocations.
     check(c, "staticMethod();",
           MessageKind.MISSING_ARGUMENT);
     check(c, "staticMethod(1);",
           NOT_ASSIGNABLE);
     check(c, "staticMethod('string');");
     check(c, "int k = staticMethod('string');");
     check(c, "String k = staticMethod('string');",
           NOT_ASSIGNABLE);
-    check(d, "staticMethod();", MessageKind.METHOD_NOT_FOUND);
-    check(d, "staticMethod(1);", MessageKind.METHOD_NOT_FOUND);
-    check(d, "staticMethod('string');", MessageKind.METHOD_NOT_FOUND);
-    check(d, "int k = staticMethod('string');", MessageKind.METHOD_NOT_FOUND);
-    check(d, "String k = staticMethod('string');", MessageKind.METHOD_NOT_FOUND);
+    check(d, "staticMethod();", MessageKind.UNDEFINED_METHOD);
+    check(d, "staticMethod(1);", MessageKind.UNDEFINED_METHOD);
+    check(d, "staticMethod('string');", MessageKind.UNDEFINED_METHOD);
+    check(d, "int k = staticMethod('string');", MessageKind.UNDEFINED_METHOD);
+    check(d, "String k = staticMethod('string');", MessageKind.UNDEFINED_METHOD);
 
     // Invocation on dynamic variable.
     check(c, "e.foo();");
     check(c, "e.foo(1);");
     check(c, "e.foo('string');");
 
     // Invocation on unresolved variable.
-    check(c, "foo();", MessageKind.METHOD_NOT_FOUND);
-    check(c, "foo(1);", MessageKind.METHOD_NOT_FOUND);
-    check(c, "foo('string');", MessageKind.METHOD_NOT_FOUND);
-    check(c, "foo(a: 'string');", MessageKind.METHOD_NOT_FOUND);
+    check(c, "foo();", MessageKind.UNDEFINED_METHOD);
+    check(c, "foo(1);", MessageKind.UNDEFINED_METHOD);
+    check(c, "foo('string');", MessageKind.UNDEFINED_METHOD);
+    check(c, "foo(a: 'string');", MessageKind.UNDEFINED_METHOD);
     check(c, "foo(a: localMethod(1));",
-          [MessageKind.METHOD_NOT_FOUND, NOT_ASSIGNABLE]);
+          [MessageKind.UNDEFINED_METHOD, NOT_ASSIGNABLE]);
   });
 }
 
 void testFunctionCall(MockCompiler compiler) {
   compiler.parseScript(CLASS_WITH_METHODS);
 
   check(String text, [expectedWarnings]){
     analyze(compiler,
             """{
                ClassWithMethods x;
@@ skipping 460 matching lines @@
   compiler.parseScript(script);
   ClassElement foo = compiler.mainApp.find("Foo");
   foo.ensureResolved(compiler.resolution);
   Element method = foo.lookupLocalMember('method');
 
   analyzeIn(compiler, method, "{ Type type = T; }");
   analyzeIn(compiler, method, "{ T type = T; }", warnings: NOT_ASSIGNABLE);
   analyzeIn(compiler, method, "{ int type = T; }", warnings: NOT_ASSIGNABLE);
 
   analyzeIn(compiler, method, "{ String typeName = T.toString(); }");
-  analyzeIn(compiler, method, "{ T.foo; }", warnings: MEMBER_NOT_FOUND);
+  analyzeIn(compiler, method, "{ T.foo; }", warnings: UNDEFINED_GETTER);
   analyzeIn(compiler, method, "{ T.foo = 0; }",
-      warnings: MessageKind.SETTER_NOT_FOUND);
+      warnings: MessageKind.UNDEFINED_SETTER);
   analyzeIn(compiler, method, "{ T.foo(); }",
-      warnings: MessageKind.METHOD_NOT_FOUND);
+      warnings: MessageKind.UNDEFINED_METHOD);
   analyzeIn(compiler, method, "{ T + 1; }",
-      warnings: MessageKind.OPERATOR_NOT_FOUND);
+      warnings: MessageKind.UNDEFINED_OPERATOR);
 }
 
 void testTypeVariableLookup1(MockCompiler compiler) {
   String script = """
 class Foo {
   int field;
   void method(int argument) {}
   int operator +(Foo foo) {}
   int get getter => 21;
 }
@@ skipping 13 matching lines @@
   test(String expression, [message]) {
     analyzeIn(compiler, methodTest, "{ $expression; }", warnings: message);
   }
 
   test('s.field');
   test('s.method(1)');
   test('s + s');
   test('s.getter');
 
   test('t.toString');
-  test('t.field', MEMBER_NOT_FOUND);
-  test('t.method(1)', MessageKind.METHOD_NOT_FOUND);
-  test('t + t', MessageKind.OPERATOR_NOT_FOUND);
-  test('t.getter', MEMBER_NOT_FOUND);
+  test('t.field', UNDEFINED_GETTER);
+  test('t.method(1)', MessageKind.UNDEFINED_METHOD);
+  test('t + t', MessageKind.UNDEFINED_OPERATOR);
+  test('t.getter', UNDEFINED_GETTER);
 
   test('s.field = "hest"', NOT_ASSIGNABLE);
   test('s.method("hest")', NOT_ASSIGNABLE);
   test('s + "hest"', NOT_ASSIGNABLE);
   test('String v = s.getter', NOT_ASSIGNABLE);
 }
 
 void testTypeVariableLookup2(MockCompiler compiler) {
   String script = """
 class Foo {
@@ skipping 33 matching lines @@
   compiler.parseScript(script);
   ClassElement classTest = compiler.mainApp.find("Test");
   classTest.ensureResolved(compiler.resolution);
   FunctionElement methodTest = classTest.lookupLocalMember("test");
 
   test(String expression, [message]) {
     analyzeIn(compiler, methodTest, "{ $expression; }", warnings: message);
   }
 
   test('s.toString');
-  test('s.field', MEMBER_NOT_FOUND);
-  test('s.method(1)', MessageKind.METHOD_NOT_FOUND);
-  test('s + s', MessageKind.OPERATOR_NOT_FOUND);
-  test('s.getter', MEMBER_NOT_FOUND);
+  test('s.field', UNDEFINED_GETTER);
+  test('s.method(1)', MessageKind.UNDEFINED_METHOD);
+  test('s + s', MessageKind.UNDEFINED_OPERATOR);
+  test('s.getter', UNDEFINED_GETTER);
 }
 
 void testFunctionTypeLookup(MockCompiler compiler) {
   check(String code, {warnings}) {
     analyze(compiler, code, warnings: warnings);
   }
 
   check('(int f(int)) => f.toString;');
   check('(int f(int)) => f.toString();');
-  check('(int f(int)) => f.foo;', warnings: MEMBER_NOT_FOUND);
-  check('(int f(int)) => f.foo();', warnings: MessageKind.METHOD_NOT_FOUND);
+  check('(int f(int)) => f.foo;', warnings: UNDEFINED_GETTER);
+  check('(int f(int)) => f.foo();', warnings: MessageKind.UNDEFINED_METHOD);
 }
 
 void testTypedefLookup(MockCompiler compiler) {
   check(String code, {warnings}) {
     analyze(compiler, code, warnings: warnings);
   }
 
   compiler.parseScript("typedef int F(int);");
   check('(F f) => f.toString;');
   check('(F f) => f.toString();');
-  check('(F f) => f.foo;', warnings: MEMBER_NOT_FOUND);
-  check('(F f) => f.foo();', warnings: MessageKind.METHOD_NOT_FOUND);
+  check('(F f) => f.foo;', warnings: UNDEFINED_GETTER);
+  check('(F f) => f.foo();', warnings: MessageKind.UNDEFINED_METHOD);
 }
 
 void testTypeLiteral(MockCompiler compiler) {
   check(String code, {warnings}) {
     analyze(compiler, code, warnings: warnings);
   }
 
   final String source = r"""class Class {
                               static var field = null;
                               static method() {}
@@ skipping 13 matching lines @@
   // Check access as argument.
   check('m(Type val) => m(int);');
   check('m(int val) => m(int);', warnings: NOT_ASSIGNABLE);
 
   // Check access as argument in member access.
   check('m(Type val) => m(int).foo;');
   check('m(int val) => m(int).foo;', warnings: NOT_ASSIGNABLE);
 
   // Check static property access.
   check('m() => Class.field;');
-  check('m() => (Class).field;', warnings: MEMBER_NOT_FOUND);
+  check('m() => (Class).field;', warnings: UNDEFINED_GETTER);
 
   // Check static method access.
   check('m() => Class.method();');
-  check('m() => (Class).method();', warnings: MessageKind.METHOD_NOT_FOUND);
+  check('m() => (Class).method();', warnings: MessageKind.UNDEFINED_METHOD);
 
   // Check access in invocation.
   check('m() => Class();', warnings: MessageKind.NOT_CALLABLE);
   check('m() => dynamic();', warnings: MessageKind.NOT_CALLABLE);
 }
 
 Future testInitializers(MockCompiler compiler) {
   Future check(String text, [expectedWarnings]) {
     return analyzeTopLevel(text, expectedWarnings);
   }
@@ skipping 248 matching lines @@
   check("Class.staticField += 0;", NOT_ASSIGNABLE);
   // String is not assignable to int (the argument type of the operator + on the
   // getter) and num (the result type of the operation) is not assignable to
   // String (the type of the setter).
   check("Class.staticField += '';",
         [NOT_ASSIGNABLE, NOT_ASSIGNABLE]);
 
   check("int v = c.overriddenField;");
   check("c.overriddenField = 0;");
   check("int v = c.getterField;");
-  check("c.getterField = 0;", MessageKind.SETTER_NOT_FOUND);
-  check("int v = c.setterField;", MessageKind.GETTER_NOT_FOUND);
+  check("c.getterField = 0;", MessageKind.UNDEFINED_SETTER);
+  check("int v = c.setterField;",
+      MessageKind.UNDEFINED_INSTANCE_GETTER_BUT_SETTER);
   check("c.setterField = 0;");
 
   check("int v = gc.overriddenField;");
   check("gc.overriddenField = 0;");
   check("int v = gc.setterField;");
   check("gc.setterField = 0;");
   check("int v = gc.getterField;");
-  check("gc.getterField = 0;", MessageKind.SETTER_NOT_FOUND);
+  check("gc.getterField = 0;", MessageKind.UNDEFINED_SETTER);
 
   check("int v = sc.overriddenField;");
   check("sc.overriddenField = 0;");
   check("int v = sc.getterField;");
   check("sc.getterField = 0;");
-  check("int v = sc.setterField;", MessageKind.GETTER_NOT_FOUND);
+  check("int v = sc.setterField;",
+      MessageKind.UNDEFINED_INSTANCE_GETTER_BUT_SETTER);
   check("sc.setterField = 0;");
 }
 
 testTypePromotionHints(MockCompiler compiler) {
   compiler.parseScript(r'''class A {
                              var a = "a";
                            }
                            class B extends A {
                              var b = "b";
                            }
@@ skipping 20 matching lines @@
             warnings: warnings,
             hints: hints,
             infos: infos);
   }
 
   check(r'''
             A a = new B();
             if (a is C) {
               var x = a.c;
             }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [MessageKind.NOT_MORE_SPECIFIC_SUBTYPE],
         infos: []);
 
   check(r'''
             A a = new B();
             if (a is C) {
               var x = '${a.c}${a.c}';
             }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND,
-                   MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER,
+                   MessageKind.UNDEFINED_GETTER],
         hints: [MessageKind.NOT_MORE_SPECIFIC_SUBTYPE],
         infos: []);
 
   check(r'''
             A a = new B();
             if (a is C) {
               var x = '${a.d}${a.d}'; // Type promotion wouldn't help.
             }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND,
-                   MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER,
+                   MessageKind.UNDEFINED_GETTER],
         hints: [],
         infos: []);
 
   check('''
            D<int> d = new E();
            if (d is E) { // Suggest E<int>.
              var x = d.e;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
                              {'shownTypeSuggestion': 'E<int>'})],
         infos: []);
 
   check('''
            D<int> d = new F();
            if (d is F) { // Suggest F<int, dynamic>.
              var x = d.f;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
                              {'shownTypeSuggestion': 'F<int, dynamic>'})],
         infos: []);
 
   check('''
            D<int> d = new G();
            if (d is G) { // Suggest G<int>.
              var x = d.f;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
                              {'shownTypeSuggestion': 'G<int>'})],
         infos: []);
 
   check('''
            F<double, int> f = new G();
            if (f is G) { // Cannot suggest a more specific type.
              var x = f.g;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [MessageKind.NOT_MORE_SPECIFIC],
         infos: []);
 
   check('''
            D<int> d = new E();
            if (d is E) {
              var x = d.f; // Type promotion wouldn't help.
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [],
         infos: []);
 
   check('''
            A a = new B();
            if (a is B) {
              a = null;
              var x = a.b;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [MessageKind.POTENTIAL_MUTATION],
         infos: [MessageKind.POTENTIAL_MUTATION_HERE]);
 
   check('''
            A a = new B();
            if (a is B) {
              a = null;
              var x = a.c; // Type promotion wouldn't help.
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [],
         infos: []);
 
   check('''
            A a = new B();
            local() { a = new A(); }
            if (a is B) {
              var x = a.b;
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [MessageKind.POTENTIAL_MUTATION_IN_CLOSURE],
         infos: [MessageKind.POTENTIAL_MUTATION_IN_CLOSURE_HERE]);
 
   check('''
            A a = new B();
            local() { a = new A(); }
            if (a is B) {
              var x = a.c; // Type promotion wouldn't help.
            }''',
-        warnings: [MessageKind.MEMBER_NOT_FOUND],
+        warnings: [MessageKind.UNDEFINED_GETTER],
         hints: [],
         infos: []);
 
   check('''
            A a = new B();
            if (a is B) {
              var x = () => a;
              var y = a.b;
            }
            a = new A();''',
-      warnings: [MessageKind.MEMBER_NOT_FOUND],
+      warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.ACCESSED_IN_CLOSURE],
       infos: [MessageKind.ACCESSED_IN_CLOSURE_HERE,
               MessageKind.POTENTIAL_MUTATION_HERE]);
 
   check('''
            A a = new B();
            if (a is B) {
              var x = () => a;
              var y = a.c; // Type promotion wouldn't help.
            }
            a = new A();''',
-      warnings: [MessageKind.MEMBER_NOT_FOUND],
+      warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [],
       infos: []);
 }
 
 void testCascade(MockCompiler compiler) {
   compiler.parseScript(r'''typedef A AFunc();
                            typedef Function FuncFunc();
                            class A {
                              A a;
                              B b;
@@ skipping 33 matching lines @@
         warnings: NOT_ASSIGNABLE);
 
   check('B b = new A()..b;',
         warnings: NOT_ASSIGNABLE);
 
   check('B b = new A().b;');
 
   check('new A().b..b;');
 
   check('new A().b..a;',
-        warnings: MEMBER_NOT_FOUND);
+        warnings: UNDEFINED_GETTER);
 
   check('B b = new A().b..c;');
 
   check('C c = new A().b..c;',
         warnings: NOT_ASSIGNABLE);
 
   check('A a = new A()..a = new A();');
 
   check('A a = new A()..b = new B();');
 
@@ skipping 395 matching lines @@
   TreeElements elements = compiler.resolveNodeStatement(node, element);
   TypeCheckerVisitor checker = new TypeCheckerVisitor(
       compiler, elements, compiler.types);
   DiagnosticCollector collector = compiler.diagnosticCollector;
   collector.clear();
   checker.analyze(node);
   generateOutput(compiler, text);
   compareWarningKinds(text, warnings, collector.warnings);
   compareWarningKinds(text, hints, collector.hints);
 }