Resolve not-equals operator

pkg/analyzer/lib/src/generated/element_resolver.dart

 // Copyright (c) 2014, 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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 149 matching lines @@
         }
       }
     }
     return null;
   }
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     sc.Token operator = node.operator;
     if (operator.isUserDefinableOperator) {
-      Expression leftOperand = node.leftOperand;
-      if (leftOperand != null) {
-        String methodName = operator.lexeme;
-        DartType staticType = _getStaticType(leftOperand);
-        MethodElement staticMethod =
-            _lookUpMethod(leftOperand, staticType, methodName);
-        node.staticElement = staticMethod;
-        DartType propagatedType = _getPropagatedType(leftOperand);
-        MethodElement propagatedMethod =
-            _lookUpMethod(leftOperand, propagatedType, methodName);
-        node.propagatedElement = propagatedMethod;
-        if (_shouldReportMissingMember(staticType, staticMethod)) {
-          _recordUndefinedToken(
-              staticType.element,
-              StaticTypeWarningCode.UNDEFINED_OPERATOR,
-              operator,
-              [methodName, staticType.displayName]);
-        } else if (_enableHints &&
-            _shouldReportMissingMember(propagatedType, propagatedMethod) &&
-            !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
-          _recordUndefinedToken(
-              propagatedType.element,
-              HintCode.UNDEFINED_OPERATOR,
-              operator,
-              [methodName, propagatedType.displayName]);
-        }
+      _resolveBinaryExpression(node, operator.lexeme);
+    } else if (operator.type == sc.TokenType.BANG_EQ) {
+      _resolveBinaryExpression(node, sc.TokenType.EQ_EQ.lexeme);
+    }
+    return null;
+  }
+
+  void _resolveBinaryExpression(BinaryExpression node, String methodName) {

[scheglov, 2014/11/21 21:18:54]

Sort members?

+    Expression leftOperand = node.leftOperand;
+    if (leftOperand != null) {
+      DartType staticType = _getStaticType(leftOperand);
+      MethodElement staticMethod =
+          _lookUpMethod(leftOperand, staticType, methodName);
+      node.staticElement = staticMethod;
+      DartType propagatedType = _getPropagatedType(leftOperand);
+      MethodElement propagatedMethod =
+          _lookUpMethod(leftOperand, propagatedType, methodName);
+      node.propagatedElement = propagatedMethod;
+      if (_shouldReportMissingMember(staticType, staticMethod)) {
+        _recordUndefinedToken(
+            staticType.element,
+            StaticTypeWarningCode.UNDEFINED_OPERATOR,
+            node.operator,
+            [methodName, staticType.displayName]);
+      } else if (_enableHints &&
+          _shouldReportMissingMember(propagatedType, propagatedMethod) &&
+          !_memberFoundInSubclass(propagatedType.element, methodName, true, false)) {
+        _recordUndefinedToken(
+            propagatedType.element,
+            HintCode.UNDEFINED_OPERATOR,
+            node.operator,
+            [methodName, propagatedType.displayName]);
       }
     }
-    return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     _lookupLabel(node, node.label);
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
@@ skipping 2865 matching lines @@
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {
   }
 }