Warn about overriding operator== but not hashCode.

dart/sdk/lib/_internal/compiler/implementation/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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 760 matching lines @@
     } else if (isMinusOperator(value)) {
       isMinus = true;
       messageKind = MessageKind.MINUS_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
     } else if (isUnaryOperator(value)) {
       messageKind = MessageKind.UNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 0;
     } else if (isBinaryOperator(value)) {
       messageKind = MessageKind.BINARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 1;
+      if (identical(value, '==')) checkOverrideHashCode(member);
     } else if (isTernaryOperator(value)) {
       messageKind = MessageKind.TERNARY_OPERATOR_BAD_ARITY;
       requiredParameterCount = 2;
     } else {
       compiler.internalErrorOnElement(function,
           'Unexpected user defined operator $value');
     }
     checkArity(function, requiredParameterCount, messageKind, isMinus);
   }
 
+  void checkOverrideHashCode(FunctionElement operatorEquals) {
+    if (operatorEquals.isAbstract(compiler)) return;
+    ClassElement cls = operatorEquals.getEnclosingClass();
+    Element hashCodeImplementation =
+        cls.lookupLocalMember(const SourceString('hashCode'));
+    if (hashCodeImplementation != null) return;
+    compiler.reportHint(
+        operatorEquals, MessageKind.OVERRIDE_EQUALS_NOT_HASH_CODE,
+        {'class': cls.name.slowToString()});
+  }
+
   void checkArity(FunctionElement function,
                   int requiredParameterCount, MessageKind messageKind,
                   bool isMinus) {
     FunctionExpression node = function.parseNode(compiler);
     FunctionSignature signature = function.computeSignature(compiler);
     if (signature.requiredParameterCount != requiredParameterCount) {
       Node errorNode = node;
       if (node.parameters != null) {
         if (isMinus ||
             signature.requiredParameterCount < requiredParameterCount) {
@@ skipping 1428 matching lines @@
     }
   }
 
   visitSend(Send node) {
     bool oldSendIsMemberAccess = sendIsMemberAccess;
     sendIsMemberAccess = node.isPropertyAccess || node.isCall;
     Element target = resolveSend(node);
     sendIsMemberAccess = oldSendIsMemberAccess;
 
     if (target != null && target == compiler.mirrorSystemGetNameFunction) {
-      compiler.reportWarningCode(
+      compiler.reportHint(
           node.selector, MessageKind.STATIC_FUNCTION_BLOAT,
           {'class': compiler.mirrorSystemClass.name,
            'name': compiler.mirrorSystemGetNameFunction.name});
     }
 
     if (!Elements.isUnresolved(target)) {
       if (target.isAbstractField()) {
         AbstractFieldElement field = target;
         target = field.getter;
         if (target == null && !inInstanceContext) {
@@ skipping 399 matching lines @@
           compiler.reportErrorCode(argumentNode, MessageKind.STRING_EXPECTED,
                                    {'type': type});
         } else {
           StringConstant stringConstant = name;
           String nameString = stringConstant.toDartString().slowToString();
           if (validateSymbol(argumentNode, nameString)) {
             world.registerConstSymbol(nameString, mapping);
           }
         }
       } else {
-        compiler.reportWarningCode(
+        compiler.reportHint(
             node.newToken, MessageKind.NON_CONST_BLOAT,
             {'name': compiler.symbolClass.name});
         world.registerNewSymbol(mapping);
       }
     }
 
     return null;
   }
 
   bool validateSymbol(Node node, String name) {
@@ skipping 1384 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }