Optimize more megamorphic dispatch sites

pkg/analyzer/lib/src/context/cache.dart

 // Copyright (c) 2015, 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 analyzer.src.context.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/dart/element/element.dart'
@@ skipping 585 matching lines @@
         deltaResult == DeltaResult.INVALIDATE_NO_DELTA) {
       _resultMap.remove(descriptor);
 //      {
 //        String indent = '  ' * level;
 //        print('[$id]$indent invalidate $descriptor for $target');
 //      }
     }
     // Stop depending on other results.
     if (deltaResult != DeltaResult.KEEP_CONTINUE) {
       TargetedResult thisResult = new TargetedResult(target, descriptor);
-      for (TargetedResult dependedOnResult in thisData.dependedOnResults) {
-        for (AnalysisCache cache in _partition.containingCaches) {
+      List<AnalysisCache> caches = _partition.containingCaches;
+      int cacheLength = caches.length;
+      List<TargetedResult> results = thisData.dependedOnResults;
+      int resultLength = results.length;
+      for (int i = 0; i < resultLength; i++) {
+        TargetedResult dependedOnResult = results[i];
+        for (int j = 0; j < cacheLength; j++) {
+          AnalysisCache cache = caches[j];
           CacheEntry entry = cache.get(dependedOnResult.target);
           if (entry != null) {
             ResultData data =
                 entry.getResultDataOrNull(dependedOnResult.result);
             if (data != null) {
               data.dependentResults.remove(thisResult);
             }
           }
         }
       }
@@ skipping 11 matching lines @@
     // Notify controller.
     _partition.onResultInvalidated
         .add(new InvalidatedResult(this, descriptor, thisData.value));
   }
 
   /**
    * Invalidates all the results of this entry, with propagation.
    */
   void _invalidateAll() {
     List<ResultDescriptor> results = _resultMap.keys.toList();
-    for (ResultDescriptor result in results) {
+    int length = results.length;
+    for (int i = 0; i < length; i++) {
+      ResultDescriptor result = results[i];
       _invalidate(nextInvalidateId++, result, null, 0);
     }
   }
 
   /**
    * Invalidate results that depend on [thisData].
    */
   void _invalidateDependentResults(
       int id, ResultData thisData, Delta delta, int level) {
     // It is necessary to copy the results to a list to avoid a concurrent
     // modification of the set of dependent results.
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
     List<TargetedResult> dependentResults = thisData.dependentResults.toList();
-    for (TargetedResult dependentResult in dependentResults) {
-      for (AnalysisCache cache in _partition.containingCaches) {
+    int resultLength = dependentResults.length;
+    for (int i = 0; i < resultLength; i++) {
+      TargetedResult dependentResult = dependentResults[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
         CacheEntry entry = cache.get(dependentResult.target);
         if (entry != null) {
           entry._invalidate(id, dependentResult.result, delta, level);
         }
       }
     }
   }
 
   /**
    * If the given `target` is an element, mark it as being a cache key.
    */
   void _markAsCacheKey(AnalysisTarget target) {
     if (target is ElementImpl) {
       target.setModifier(Modifier.CACHE_KEY, true);
     }
   }
 
   /**
    * Set the [dependedOn] on which this result depends.
    */
   void _setDependedOnResults(ResultData thisData, TargetedResult thisResult,
       List<TargetedResult> dependedOn) {
-    thisData.dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      for (AnalysisCache cache in _partition.containingCaches) {
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
+
+    List<TargetedResult> oldResults = thisData.dependedOnResults;
+    int oldLength = oldResults.length;
+    for (int i = 0; i < oldLength; i++) {
+      TargetedResult dependedOnResult = oldResults[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
         CacheEntry entry = cache.get(dependedOnResult.target);
         if (entry != null) {
           ResultData data = entry.getResultDataOrNull(dependedOnResult.result);
           if (data != null) {
             data.dependentResults.remove(thisResult);
           }
         }
       }
-    });
+    }
     thisData.dependedOnResults = dependedOn;
-    thisData.dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      for (AnalysisCache cache in _partition.containingCaches) {
+    int newLength = dependedOn.length;
+    for (int i = 0; i < newLength; i++) {
+      TargetedResult dependedOnResult = dependedOn[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
         CacheEntry entry = cache.get(dependedOnResult.target);
         if (entry != null) {
           ResultData data = entry.getResultDataOrNull(dependedOnResult.result);
           if (data != null) {
             data.dependentResults.add(thisResult);
           }
         }
       }
-    });
+    }
   }
 
   /**
    * Set states of the given and dependent results to [CacheState.ERROR] and
    * their values to the corresponding default values
    */
   void _setErrorState(ResultDescriptor descriptor, CaughtException exception) {
     ResultData thisData = getResultData(descriptor);
     // Set the error state.
     _exception = exception;
     thisData.state = CacheState.ERROR;
     thisData.value = descriptor.defaultValue;
     // Propagate the error state.
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
     thisData.dependentResults.forEach((TargetedResult dependentResult) {
-      for (AnalysisCache cache in _partition.containingCaches) {
+      for (int j = 0; j < cacheLength; j++) {

[scheglov, 2016/05/25 17:44:46]

Could be 'i'.

[Brian Wilkerson, 2016/05/25 17:48:42]

Done

+        AnalysisCache cache = caches[j];
         CacheEntry entry = cache.get(dependentResult.target);
         if (entry != null) {
           entry._setErrorState(dependentResult.result, exception);
         }
       }
     });
   }
 
   /**
    * Set the value of the flag with the given [index] to the given [value].
@@ skipping 599 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }