Make table entries on analysis server's '/status' page clickable.

pkg/analyzer/lib/src/generated/engine.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;
 
 import 'dart:collection';
@@ skipping 830 matching lines @@
 
   /**
    * Set the source factory used to create the sources that can be analyzed in this context to the
    * given source factory. Clients can safely assume that all analysis results have been
    * invalidated.
    *
    * @param factory the source factory used to create the sources that can be analyzed in this
    *          context
    */
   void set sourceFactory(SourceFactory factory);
+
+  /**
+   * Call the given callback function for eache cache item in the context.
+   */
+  void visitCacheItems(void callback(Source source, SourceEntry dartEntry,

[Brian Wilkerson, 2014/10/29 13:51:02]

AnalysisContext represents the public API, and I really don't want this method
in the public API.

There is an internal interface named InternalAnalysisContext, but the way
everything else has been done is by adding information to
AnalysisContextStatisticsImpl. One of the reasons for that choice was to avoid
synchronization issues, which presumably isn't important any more, so perhaps it
should be rethought.

If we do go with a general access mechanism, I think it would be better to have

  void visitCacheItems(void callback(Source source, SourceEntry entry));

Most clients don't need to visit a single entry more than once, so this would be
more efficient.

[Paul Berry, 2014/10/29 18:39:11]

Ok.  As discussed in person, I've moved this function to the
InternalAnalysisContext class for now.  We can work on the other proposed
improvements in future CL's.

+                                     DataDescriptor rowDesc,
+                                     CacheState state));
 }
 
 /**
  * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext].
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
   /**
    * The difference between the maximum cache size and the maximum priority order size. The priority
    * list must be capped so that it is less than the cache size. Failure to do so can result in an
    * infinite loop in performAnalysisTask() because re-caching one AST structure can cause another
@@ skipping 745 matching lines @@
     //
     WorkManager_WorkIterator iterator = _workManager.iterator();
     while (iterator.hasNext) {
       Source source = iterator.next();
       _getSourcesNeedingProcessing(source, _cache.get(source), false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   @override
-  AnalysisContextStatistics get statistics {
+  void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
+                                     DataDescriptor rowDesc,
+                                     CacheState state)) {
+    void handleCacheItem(Source source, SourceEntry dartEntry,
+                         DataDescriptor descriptor) {
+      callback(source, dartEntry, descriptor, dartEntry.getState(descriptor));
+    }
+    void handleCacheItemInLibrary(DartEntry dartEntry, Source librarySource,
+                                  DataDescriptor descriptor) {
+      callback(librarySource, dartEntry, descriptor,
+          dartEntry.getStateInLibrary(descriptor, librarySource));
+    }
+
     bool hintsEnabled = _options.hint;
-    AnalysisContextStatisticsImpl statistics = new AnalysisContextStatisticsImpl();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
+      Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
-        Source source = iterator.key;
         DartEntry dartEntry = sourceEntry;
         SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
         // get library independent values
-        statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
-        statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
-        statistics.putCacheItem(dartEntry, DartEntry.PARSED_UNIT);
-        statistics.putCacheItem(dartEntry, DartEntry.SOURCE_KIND);
+        handleCacheItem(source, dartEntry, SourceEntry.LINE_INFO);
+        handleCacheItem(source, dartEntry, DartEntry.PARSE_ERRORS);
+        handleCacheItem(source, dartEntry, DartEntry.PARSED_UNIT);
+        handleCacheItem(source, dartEntry, DartEntry.SOURCE_KIND);
         if (kind == SourceKind.LIBRARY) {
-          statistics.putCacheItem(dartEntry, DartEntry.ELEMENT);
-          statistics.putCacheItem(dartEntry, DartEntry.EXPORTED_LIBRARIES);
-          statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
-          statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
-          statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
-          statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
+          handleCacheItem(source, dartEntry, DartEntry.ELEMENT);
+          handleCacheItem(source, dartEntry, DartEntry.EXPORTED_LIBRARIES);
+          handleCacheItem(source, dartEntry, DartEntry.IMPORTED_LIBRARIES);
+          handleCacheItem(source, dartEntry, DartEntry.INCLUDED_PARTS);
+          handleCacheItem(source, dartEntry, DartEntry.IS_CLIENT);
+          handleCacheItem(source, dartEntry, DartEntry.IS_LAUNCHABLE);
           // The public namespace isn't computed by performAnalysisTask() and therefore isn't
           // interesting.
-          //statistics.putCacheItem(dartEntry, DartEntry.PUBLIC_NAMESPACE);
+          //handleCacheItem(key, dartEntry, DartEntry.PUBLIC_NAMESPACE);
         }
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
-          statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
-          statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
+          handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
+          handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
           if (_generateSdkErrors || !source.isInSystemLibrary) {
-            statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
+            handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
             if (hintsEnabled) {
-              statistics.putCacheItemInLibrary(dartEntry, librarySource, DartEntry.HINTS);
+              handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.HINTS);
             }
           }
         }
       } else if (sourceEntry is HtmlEntry) {
         HtmlEntry htmlEntry = sourceEntry;
-        statistics.putCacheItem(htmlEntry, SourceEntry.LINE_INFO);
-        statistics.putCacheItem(htmlEntry, HtmlEntry.PARSE_ERRORS);
-        statistics.putCacheItem(htmlEntry, HtmlEntry.PARSED_UNIT);
-        statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
-        statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLVED_UNIT);
+        handleCacheItem(source, htmlEntry, SourceEntry.LINE_INFO);
+        handleCacheItem(source, htmlEntry, HtmlEntry.PARSE_ERRORS);
+        handleCacheItem(source, htmlEntry, HtmlEntry.PARSED_UNIT);
+        handleCacheItem(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+        handleCacheItem(source, htmlEntry, HtmlEntry.RESOLVED_UNIT);
         // We are not currently recording any hints related to HTML.
-        // statistics.putCacheItem(htmlEntry, HtmlEntry.HINTS);
+        // handleCacheItem(key, htmlEntry, HtmlEntry.HINTS);
       }
     }
+  }
+
+  @override
+  AnalysisContextStatistics get statistics {
+    AnalysisContextStatisticsImpl statistics = new AnalysisContextStatisticsImpl();
+    visitCacheItems(statistics._internalPutCacheItem);
     statistics.partitionData = _cache.partitionData;
     return statistics;
   }
 
   @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     if (coreSource == null) {
       throw new AnalysisException("Could not create a source for dart:core");
     }
@@ skipping 3431 matching lines @@
 
   @override
   List<CaughtException> get exceptions => new List.from(_exceptions);
 
   @override
   List<AnalysisContextStatistics_PartitionData> get partitionData => _partitionData;
 
   @override
   List<Source> get sources => _sources;
 
-  void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
-    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
-  }
-
-  void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
-    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
-  }
-
   /**
    * Set the partition data returned by this object to the given data.
    */
   void set partitionData(List<AnalysisContextStatistics_PartitionData> data) {
     _partitionData = data;
   }
 
-  void _internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
+  void _internalPutCacheItem(Source source, SourceEntry dartEntry,
+                             DataDescriptor rowDesc, CacheState state) {
     String rowName = rowDesc.toString();
     AnalysisContextStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContextStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContextStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
     row._incState(state);
     if (state == CacheState.ERROR) {
       CaughtException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContextStatisticsImpl_CacheRowImpl implements AnalysisContextStatistics_CacheRow {
   final String name;
 
-  int _errorCount = 0;
-
-  int _flushedCount = 0;
-
-  int _inProcessCount = 0;
-
-  int _invalidCount = 0;
-
-  int _validCount = 0;
+  Map<CacheState, int> _counts = <CacheState, int>{};
 
   AnalysisContextStatisticsImpl_CacheRowImpl(this.name);
 
   @override
   bool operator ==(Object obj) => obj is AnalysisContextStatisticsImpl_CacheRowImpl && obj.name == name;
 
   @override
-  int get errorCount => _errorCount;
+  int get errorCount => getCount(CacheState.ERROR);
 
   @override
-  int get flushedCount => _flushedCount;
+  int get flushedCount => getCount(CacheState.FLUSHED);
 
   @override
-  int get inProcessCount => _inProcessCount;
+  int get inProcessCount => getCount(CacheState.IN_PROCESS);
 
   @override
-  int get invalidCount => _invalidCount;
+  int get invalidCount => getCount(CacheState.INVALID);
 
   @override
-  int get validCount => _validCount;
+  int get validCount => getCount(CacheState.VALID);
 
   @override
   int get hashCode => name.hashCode;
 
+  @override
+  int getCount(CacheState state) {
+    int count = _counts[state];
+    if (count != null) {
+      return count;
+    } else {
+      return 0;
+    }
+  }
+
   void _incState(CacheState state) {
-    if (state == CacheState.ERROR) {
-      _errorCount++;
-    }
-    if (state == CacheState.FLUSHED) {
-      _flushedCount++;
-    }
-    if (state == CacheState.IN_PROCESS) {
-      _inProcessCount++;
-    }
-    if (state == CacheState.INVALID) {
-      _invalidCount++;
-    }
-    if (state == CacheState.VALID) {
-      _validCount++;
+    if (_counts[state] == null) {
+      _counts[state] = 1;
+    } else {
+      _counts[state]++;
     }
   }
 }
 
 class AnalysisContextStatisticsImpl_PartitionDataImpl implements AnalysisContextStatistics_PartitionData {
   final int astCount;
 
   final int totalCount;
 
   AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount, this.totalCount);
 }
 
 /**
  * Information about single piece of data in the cache.
  */
 abstract class AnalysisContextStatistics_CacheRow {
   /**
+   * List of possible states which can be queried.
+   */
+  static const List<CacheState> STATES = const <CacheState>[

[Brian Wilkerson, 2014/10/29 13:51:02]

Use CacheState.values instead?

[Paul Berry, 2014/10/29 18:39:11]

Done.

+      CacheState.ERROR, CacheState.FLUSHED, CacheState.IN_PROCESS,
+      CacheState.INVALID, CacheState.VALID];
+
+  /**
+   * Return the number of entries whose state is [state].
+   */
+  int getCount(CacheState state);
+
+  /**
    * Return the number of entries whose state is [CacheState.ERROR].
    */
   int get errorCount;
 
   /**
    * Return the number of entries whose state is [CacheState.FLUSHED].
    */
   int get flushedCount;
 
   /**
@@ skipping 4976 matching lines @@
   void set sourceFactory(SourceFactory factory) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setSourceFactory");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.sourceFactory = factory;
     } finally {
       instrumentation.log();
     }
   }
+
+  @override
+  void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
+                                     DataDescriptor rowDesc,
+                                     CacheState state)) {
+    _basis.visitCacheItems(callback);
+  }
 }
 
 /**
  * The interface `InternalAnalysisContext` defines additional behavior for an analysis context
  * that is required by internal users of the context.
  */
 abstract class InternalAnalysisContext implements AnalysisContext {
   /**
    * Add the given source with the given information to this context.
    *
@@ skipping 3250 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }