Move more messages.

pkg/compiler/lib/src/resolution/members.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.
 
 library dart2js.resolution.members;
 
 import '../common.dart';
 import '../common/names.dart' show
     Selectors;
 import '../common/resolution.dart' show
@@ skipping 1006 matching lines @@
     // patch.
     Element target = currentClass.lookupSuperByName(name);
     // [target] may be null which means invoking noSuchMethod on super.
     if (target == null) {
       if (alternateName != null) {
         target = currentClass.lookupSuperByName(alternateName);
       }
       Element error;
       if (selector.isSetter) {
         error = reportAndCreateErroneousElement(
-          node, name.text, MessageKind.SETTER_NOT_FOUND_IN_SUPER,
+          node, name.text, MessageKind.UNDEFINED_SUPER_SETTER,
           {'className': currentClass.name, 'name': name});
       } else {
         error = reportAndCreateErroneousElement(
           node, name.text, MessageKind.NO_SUCH_SUPER_MEMBER,
           {'className': currentClass.name, 'memberName': name});
       }
       if (target == null) {
         // If a setter wasn't resolved, use the [ErroneousElement].
         target = error;
       }
@@ skipping 715 matching lines @@
     // a constructor.
 
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(karlklose): this should be reported by the caller of
     // [resolveSend] to select better warning messages for getters and
     // setters.
     ErroneousElement error = reportAndCreateErroneousElement(
-        node, name.text, MessageKind.MEMBER_NOT_FOUND,
+        node, name.text, MessageKind.UNDEFINED_GETTER,
         {'className': receiverClass.name, 'memberName': name.text});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleErroneousAccess(
         node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified update to an unresolved static class member, like
   /// `a.b = c` or `a.b++` where `a` is a class and `b` is unresolved.
   ResolutionResult handleUnresolvedStaticMemberUpdate(
       SendSet node, Name name, ClassElement receiverClass) {
     // TODO(johnniwinther): Share code with [handleStaticInstanceMemberUpdate]
     // and [handlePrivateStaticMemberUpdate].
     registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
     // TODO(johnniwinther): Produce a different error if [name] is resolves to
     // a constructor.
 
     // TODO(johnniwinther): With the simplified [TreeElements] invariant,
     // try to resolve injected elements if [currentClass] is in the patch
     // library of [receiverClass].
 
     // TODO(johnniwinther): Produce a different error for complex update.
     ErroneousElement error = reportAndCreateErroneousElement(
-        node, name.text, MessageKind.MEMBER_NOT_FOUND,
+        node, name.text, MessageKind.UNDEFINED_GETTER,
         {'className': receiverClass.name, 'memberName': name.text});
     // TODO(johnniwinther): Add an [AccessSemantics] for unresolved static
     // member access.
     return handleUpdate(node, name, new StaticAccess.unresolved(error));
   }
 
   /// Handle qualified access of an instance member, like `a.b` or `a.b()` where
   /// `a` is a class and `b` is a non-static member.
   ResolutionResult handleStaticInstanceMemberAccess(
       Send node, Name name, ClassElement receiverClass, Element member) {
@@ skipping 849 matching lines @@
   }
 
   /// Handle update of a parameter, local variable or local function.
   ResolutionResult handleLocalUpdate(Send node, Name name, Element element) {
     AccessSemantics semantics;
     ErroneousElement error;
     if (element.isParameter) {
       if (element.isFinal) {
         error = reportAndCreateErroneousElement(
             node.selector, name.text,
-            MessageKind.CANNOT_RESOLVE_SETTER, const {});
+            MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
+            {'name': name});
         semantics = new StaticAccess.finalParameter(element);
       } else {
         semantics = new StaticAccess.parameter(element);
       }
     } else if (element.isVariable) {
       if (element.isFinal || element.isConst) {
         error = reportAndCreateErroneousElement(
             node.selector, name.text,
-            MessageKind.CANNOT_RESOLVE_SETTER, const {});
+            MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
+            {'name': name});
         semantics = new StaticAccess.finalLocalVariable(element);
       } else {
         semantics = new StaticAccess.localVariable(element);
       }
     } else {
       assert(invariant(node, element.isFunction,
           message: "Unexpected local $element."));
       error = reportAndCreateErroneousElement(
           node.selector, name.text,
           MessageKind.ASSIGNING_METHOD, const {});
@@ skipping 91 matching lines @@
           selector = callStructure.callSelector;
           registry.registerDynamicUse(
               new DynamicUse(selector, null));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
-              MessageKind.CANNOT_RESOLVE_GETTER, const {});
+              MessageKind.UNDEFINED_STATIC_GETTER_BUT_SETTER,
+              {'name': name});
           break;
         default:
           reporter.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node,
           isIncompatibleInvoke
               ? new IncompatibleInvokeStructure(semantics, selector)
               : new InvokeStructure(semantics, selector));
@@ skipping 13 matching lines @@
         case AccessKind.TOPLEVEL_GETTER:
           registry.registerStaticUse(
               new StaticUse.staticGet(semantics.element));
           break;
         case AccessKind.STATIC_SETTER:
         case AccessKind.TOPLEVEL_SETTER:
         case AccessKind.UNRESOLVED:
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           member = reportAndCreateErroneousElement(
               node.selector, name.text,
-              MessageKind.CANNOT_RESOLVE_GETTER, const {});
+              MessageKind.UNDEFINED_STATIC_GETTER_BUT_SETTER,
+              {'name': name});
           break;
         default:
           reporter.internalError(node,
               "Unexpected statically resolved access $semantics.");
           break;
       }
       registry.registerSendStructure(node, new GetStructure(semantics));
       if (member.isConst) {
         FieldElement field = member;
         result = new ConstantResult(
@@ skipping 13 matching lines @@
 
   /// Handle update of a static or top level [element].
   ResolutionResult handleStaticOrTopLevelUpdate(
         SendSet node, Name name, Element element) {
     AccessSemantics semantics;
     if (element.isAbstractField) {
       AbstractFieldElement abstractField = element;
       if (abstractField.setter == null) {
         ErroneousElement error = reportAndCreateErroneousElement(
             node.selector, name.text,
-            MessageKind.CANNOT_RESOLVE_SETTER, const {});
+            MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
+            {'name': name});
         registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
 
         if (node.isComplex) {
           // `a++` or `a += b` where `a` has no setter.
           semantics = new CompoundAccessSemantics(
               element.isTopLevel
                   ? CompoundAccessKind.UNRESOLVED_TOPLEVEL_SETTER
                   : CompoundAccessKind.UNRESOLVED_STATIC_SETTER,
               abstractField.getter,
               error);
         } else {
           // `a = b` where `a` has no setter.
           semantics = element.isTopLevel
               ? new StaticAccess.topLevelGetter(abstractField.getter)
               : new StaticAccess.staticGetter(abstractField.getter);
         }
         registry.registerStaticUse(
             new StaticUse.staticGet(abstractField.getter));
       } else if (node.isComplex) {
         if (abstractField.getter == null) {
           ErroneousElement error = reportAndCreateErroneousElement(
               node.selector, name.text,
-              MessageKind.CANNOT_RESOLVE_GETTER, const {});
+              MessageKind.UNDEFINED_STATIC_GETTER_BUT_SETTER,
+              {'name': name});
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           // `a++` or `a += b` where `a` has no getter.
           semantics = new CompoundAccessSemantics(
               element.isTopLevel
                   ? CompoundAccessKind.UNRESOLVED_TOPLEVEL_GETTER
                   : CompoundAccessKind.UNRESOLVED_STATIC_GETTER,
               error,
               abstractField.setter);
           registry.registerStaticUse(
               new StaticUse.staticSet(abstractField.setter));
@@ skipping 44 matching lines @@
         // `a = b`, `a++` or `a += b` where `a` is a field.
         assert(invariant(node, member.isField,
             message: "Unexpected element: $member."));
         if (node.isComplex) {
           // `a++` or `a += b` where `a` is a field.
           registry.registerStaticUse(new StaticUse.staticGet(member));
         }
         if (member.isFinal || member.isConst) {
           ErroneousElement error = reportAndCreateErroneousElement(
                node.selector, name.text,
-               MessageKind.CANNOT_RESOLVE_SETTER, const {});
+               MessageKind.UNDEFINED_STATIC_SETTER_BUT_GETTER,
+               {'name': name});
           registry.registerFeature(Feature.THROW_NO_SUCH_METHOD);
           semantics = member.isTopLevel
               ? new StaticAccess.finalTopLevelField(member)
               : new StaticAccess.finalStaticField(member);
         } else {
           registry.registerStaticUse(new StaticUse.staticSet(member));
           semantics = member.isTopLevel
               ? new StaticAccess.topLevelField(member)
               : new StaticAccess.staticField(member);
         }
@@ skipping 1918 matching lines @@
     }
     return const NoneResult();
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(DiagnosticReporter reporter, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), reporter, node);
 }