Optimizations for hashCode.

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';
@@ skipping 3872 matching lines @@
   }
 
   @override
   CompilationUnit get unit => context.resolveCompilationUnit(source, library);
 
   @override
   int get hashCode {
     // TODO: We might want to re-visit this optimization in the future.
     // We cache the hash code value as this is a very frequently called method.
     if (_cachedHashCode == 0) {
-      _cachedHashCode = location.hashCode;
+      int hashIdentifier = identifier.hashCode;
+      Element enclosing = enclosingElement;
+      if (enclosing != null) {
+        _cachedHashCode = hashIdentifier + enclosing.hashCode;
+      } else {
+        _cachedHashCode = hashIdentifier;
+      }
     }
     return _cachedHashCode;
   }
 
   @override
   bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
       return library == this.library;
     }
     return true;
@@ skipping 5763 matching lines @@
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs);
 
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs);
 }
 
 class TypeImpl_TypePair {
   DartType _firstType;
 
   DartType _secondType;
 
+  int _cachedHashCode = 0;
+
   TypeImpl_TypePair(DartType firstType, DartType secondType) {
     this._firstType = firstType;
     this._secondType = secondType;
   }
 
   @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object is TypeImpl_TypePair) {
       TypeImpl_TypePair typePair = object;
       return _firstType == typePair._firstType && _secondType != null && _secondType == typePair._secondType;
     }
     return false;
   }
 
   @override
   int get hashCode {
-    int firstHashCode = 0;
-    if (_firstType != null) {
-      firstHashCode = _firstType.element == null ? 0 : _firstType.element.hashCode;
+    if (_cachedHashCode == 0) {
+      int firstHashCode = 0;
+      if (_firstType != null) {
+        Element firstElement = _firstType.element;
+        firstHashCode = firstElement == null ? 0 : firstElement.hashCode;
+      }
+      int secondHashCode = 0;
+      if (_secondType != null) {
+        Element secondElement = _secondType.element;
+        secondHashCode = secondElement == null ? 0 : secondElement.hashCode;
+      }
+      _cachedHashCode = firstHashCode + secondHashCode;
     }
-    int secondHashCode = 0;
-    if (_secondType != null) {
-      secondHashCode = _secondType.element == null ? 0 : _secondType.element.hashCode;
-    }
-    return firstHashCode + secondHashCode;
+    return _cachedHashCode;
   }
 }
 
 /**
  * Instances of the class `TypeParameterTypeImpl` defines the behavior of objects representing
  * the type introduced by a type parameter.
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty array of type parameter types.
@@ skipping 733 matching lines @@
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
   @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }