Use better hash computer.

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'constant.dart' show EvaluationResultImpl;
 import 'engine.dart' show AnalysisContext, AnalysisEngine, AnalysisException;
 import 'html.dart' show XmlAttributeNode, XmlTagNode;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'resolver.dart';
 import 'scanner.dart' show Keyword;
 import 'sdk.dart' show DartSdk;
 import 'source.dart';
 import 'utilities_collection.dart';
 import 'utilities_dart.dart';
+import 'package:analyzer/src/generated/utilities_general.dart';
 
 
 /**
  * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
@@ skipping 3238 matching lines @@
     }
   }
 }
 
 /**
  * The class `ElementPair` is a pair of [Element]s. [Object.==] and
  * [Object.hashCode] so this class can be used in hashed data structures.
  */
 class ElementPair {
   /**
-   * The first [Element]
+   * The first [Element].
    */
   final Element _first;
 
   /**
-   * The second [Element]
+   * The second [Element].
    */
   final Element _second;
 
   /**
+   * A cached copy of the calculated hashCode for this element.
+   */
+  int _cachedHashCode;
+
+  /**
    * The sole constructor for this class, taking two [Element]s.
    *
    * @param first the first element
    * @param second the second element
    */
-  ElementPair(this._first, this._second);
+  ElementPair(this._first, this._second) {
+    _cachedHashCode = JenkinsSmiHash.hash2(_first.hashCode, _second.hashCode);
+  }
 
   /**
    * Return the first element.
    *
    * @return the first element
    */
   Element get firstElt => _first;
 
   @override
-  int get hashCode =>
-      ObjectUtilities.combineHashCodes(_first.hashCode, _second.hashCode);
+  int get hashCode {
+    return _cachedHashCode;
+  }
 
   /**
    * Return the second element
    *
    * @return the second element
    */
   Element get secondElt => _second;
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
-    if (object is ElementPair) {
-      ElementPair elementPair = object;
-      return (_first == elementPair._first) && (_second == elementPair._second);
-    }
-    return false;
+    return object is ElementPair &&
+        _first == object._first &&
+        _second == object._second;
   }
 }
 
 /**
  * The interface `ElementVisitor` defines the behavior of objects that can be used to visit an
  * element structure.
  */
 abstract class ElementVisitor<R> {
   R visitClassElement(ClassElement element);
 
@@ skipping 5938 matching lines @@
   /**
    * Set whether this accessor is a getter to correspond to the given value.
    *
    * @param isGetter `true` if the accessor is a getter
    */
   void set getter(bool isGetter) {
     setModifier(Modifier.GETTER, isGetter);
   }
 
   @override
-  int get hashCode =>
-      ObjectUtilities.combineHashCodes(super.hashCode, isGetter ? 1 : 2);
+  int get hashCode => JenkinsSmiHash.hash2(super.hashCode, isGetter ? 1 : 2);
 
   @override
   String get identifier {
     String name = displayName;
     String suffix = isGetter ? "?" : "=";
     return "$name$suffix";
   }
 
   @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
@@ skipping 1857 matching lines @@
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes,
       List<DartType> parameterTypes) =>
       this;
 }