Re-implement the status page for the new task model

pkg/analysis_server/lib/src/status/get_handler.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 analysis_server.src.get_handler;
+library analysis_server.src.status.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/domain_execution.dart';
 import 'package:analysis_server/src/operation/operation.dart';
 import 'package:analysis_server/src/operation/operation_analysis.dart';
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/index/local_index.dart';
 import 'package:analysis_server/src/services/index/store/split_store.dart';
 import 'package:analysis_server/src/socket_server.dart';
 import 'package:analysis_server/src/status/ast_writer.dart';
 import 'package:analysis_server/src/status/element_writer.dart';
 import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
-import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/engine.dart'
+    hide AnalysisContextImpl, AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
+import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
-import 'package:analyzer/task/model.dart' as newTask;
+import 'package:analyzer/src/task/dart.dart';
+import 'package:analyzer/task/dart.dart';
+import 'package:analyzer/task/model.dart';
 import 'package:plugin/plugin.dart';
 
 /**
  * A function that can be used to generate HTML output into the given [buffer].
  * The HTML that is generated must be valid (special characters must already be
  * encoded).
  */
 typedef void HtmlGenerator(StringBuffer buffer);
 
 /**
@@ skipping 171 matching lines @@
   /**
    * Return the folder being managed by the given [analysisServer] that matches
    * the given [contextFilter], or `null` if there is none.
    */
   Folder _findFolder(AnalysisServer analysisServer, String contextFilter) {
     return analysisServer.folderMap.keys.firstWhere(
         (Folder folder) => folder.path == contextFilter, orElse: () => null);
   }
 
   /**
+   * Return any AST structure stored in the given [entry].
+   */
+  CompilationUnit _getAnyAst(CacheEntry entry) {
+    CompilationUnit unit = entry.getValue(PARSED_UNIT);
+    if (unit != null) {
+      return unit;
+    }
+    unit = entry.getValue(RESOLVED_UNIT1);
+    if (unit != null) {
+      return unit;
+    }
+    unit = entry.getValue(RESOLVED_UNIT2);
+    if (unit != null) {
+      return unit;
+    }
+    unit = entry.getValue(RESOLVED_UNIT3);
+    if (unit != null) {
+      return unit;
+    }
+    unit = entry.getValue(RESOLVED_UNIT4);
+    if (unit != null) {
+      return unit;
+    }
+    unit = entry.getValue(RESOLVED_UNIT5);
+    if (unit != null) {
+      return unit;
+    }
+    return entry.getValue(RESOLVED_UNIT);
+  }
+
+  /**
    * Return `true` if the given analysis [context] has at least one entry with
    * an exception.
    */
-  bool _hasException(AnalysisContextImpl context) {
-    bool hasException = false;
-    context.visitCacheItems((Source source, SourceEntry sourceEntry,
-        DataDescriptor rowDesc, CacheState state) {
-      if (sourceEntry.exception != null) {
-        hasException = true;
+  bool _hasException(InternalAnalysisContext context) {
+    MapIterator<AnalysisTarget, CacheEntry> iterator =
+        context.analysisCache.iterator();
+    while (iterator.moveNext()) {
+      if (iterator.value.exception != null) {
+        return true;
       }
-    });
-    return hasException;
+    }
+    return false;
   }
 
   /**
    * Return the folder in the [folderMap] with which the given [context] is
    * associated.
    */
   Folder _keyForValue(
       Map<Folder, AnalysisContext> folderMap, AnalysisContext context) {
     for (Folder folder in folderMap.keys) {
       if (folderMap[folder] == context) {
@@ skipping 52 matching lines @@
           buffer.write('<p><b>Task performace data</b></p>');
           buffer.write(
               '<table style="border-collapse: separate; border-spacing: 10px 5px;">');
           _writeRow(buffer, [
             'Task Name',
             'Count',
             'Total Time (in ms)',
             'Average Time (in ms)'
           ], header: true);
 
-          Map<Type, int> countMap = newTask.AnalysisTask.countMap;
-          Map<Type, Stopwatch> stopwatchMap = newTask.AnalysisTask.stopwatchMap;
+          Map<Type, int> countMap = AnalysisTask.countMap;
+          Map<Type, Stopwatch> stopwatchMap = AnalysisTask.stopwatchMap;
           List<Type> taskClasses = stopwatchMap.keys.toList();
           taskClasses.sort((Type first, Type second) =>
               first.toString().compareTo(second.toString()));
           int totalTime = 0;
           taskClasses.forEach((Type taskClass) {
             int count = countMap[taskClass];
             if (count == null) {
               count = 0;
             }
             int taskTime = stopwatchMap[taskClass].elapsedMilliseconds;
@@ skipping 61 matching lines @@
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
       return _returnFailure(request, 'Invalid context: $contextFilter');
     }
     String sourceUri = request.uri.queryParameters[SOURCE_QUERY_PARAM];
     if (sourceUri == null) {
       return _returnFailure(
           request, 'Query parameter $SOURCE_QUERY_PARAM required');
     }
 
-    AnalysisContextImpl context = analysisServer.folderMap[folder];
+    InternalAnalysisContext context = analysisServer.folderMap[folder];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - AST Structure', [
         'Context: $contextFilter',
         'File: $sourceUri'
       ], (HttpResponse) {
         Source source = context.sourceFactory.forUri(sourceUri);
         if (source == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
-        SourceEntry entry = context.getReadableSourceEntryOrNull(source);
+        CacheEntry entry = context.analysisCache.get(source);
         if (entry == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
-        CompilationUnit ast = (entry as DartEntry).anyParsedCompilationUnit;
+        CompilationUnit ast = _getAnyAst(entry);
         if (ast == null) {
           buffer.write('<p>null</p>');
           return;
         }
         AstWriter writer = new AstWriter(buffer);
         ast.accept(writer);
         if (writer.exceptions.isNotEmpty) {
           buffer.write('<h3>Exceptions while creating page</h3>');
           for (CaughtException exception in writer.exceptions) {
             _writeException(buffer, exception);
@@ skipping 21 matching lines @@
     if (folder == null) {
       return _returnFailure(request, 'Invalid context: $contextFilter');
     }
     String sourceUri = request.uri.queryParameters[SOURCE_QUERY_PARAM];
     if (sourceUri == null) {
       return _returnFailure(
           request, 'Query parameter $SOURCE_QUERY_PARAM required');
     }
 
     List<Folder> allContexts = <Folder>[];
-    Map<Folder, SourceEntry> entryMap = new HashMap<Folder, SourceEntry>();
+    Map<Folder, List<CacheEntry>> entryMap =
+        new HashMap<Folder, List<CacheEntry>>();
     analysisServer.folderMap
-        .forEach((Folder folder, AnalysisContextImpl context) {
+        .forEach((Folder folder, InternalAnalysisContext context) {
       Source source = context.sourceFactory.forUri(sourceUri);
       if (source != null) {
-        SourceEntry entry = context.getReadableSourceEntryOrNull(source);
-        if (entry != null) {
-          allContexts.add(folder);
-          entryMap[folder] = entry;
+        MapIterator<AnalysisTarget, CacheEntry> iterator =
+            context.analysisCache.iterator();
+        while (iterator.moveNext()) {
+          if (source == iterator.key.source) {
+            if (!allContexts.contains(folder)) {
+              allContexts.add(folder);
+            }
+            List<CacheEntry> entries = entryMap[folder];
+            if (entries == null) {
+              entries = <CacheEntry>[];
+              entryMap[folder] = entries;
+            }
+            entries.add(iterator.value);
+          }
         }
       }
     });
     allContexts.sort((Folder firstFolder, Folder secondFolder) =>
         firstFolder.path.compareTo(secondFolder.path));
-    AnalysisContextImpl context = analysisServer.folderMap[folder];
+    InternalAnalysisContext context = analysisServer.folderMap[folder];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Cache Entry', [
         'Context: $contextFilter',
         'File: $sourceUri'
       ], (HttpResponse) {
         buffer.write('<h3>Analyzing Contexts</h3><p>');
         bool first = true;
         allContexts.forEach((Folder folder) {
           if (first) {
             first = false;
           } else {
             buffer.write('<br>');
           }
-          AnalysisContextImpl analyzingContext =
+          InternalAnalysisContext analyzingContext =
               analysisServer.folderMap[folder];
           if (analyzingContext == context) {
             buffer.write(folder.path);
           } else {
             buffer.write(makeLink(CACHE_ENTRY_PATH, {
               CONTEXT_QUERY_PARAM: folder.path,
               SOURCE_QUERY_PARAM: sourceUri
             }, HTML_ESCAPE.convert(folder.path)));
           }
-          if (entryMap[folder].explicitlyAdded) {
+          if (entryMap[folder][0].explicitlyAdded) {
             buffer.write(' (explicit)');
           } else {
             buffer.write(' (implicit)');
           }
         });
         buffer.write('</p>');
 
-        SourceEntry entry = entryMap[folder];
-        if (entry == null) {
+        List<CacheEntry> entries = entryMap[folder];
+        if (entries == null) {
           buffer.write('<p>Not being analyzed in this context.</p>');
           return;
         }
-        Map<String, String> linkParameters = <String, String>{
-          CONTEXT_QUERY_PARAM: folder.path,
-          SOURCE_QUERY_PARAM: sourceUri
-        };
+        for (CacheEntry entry in entries) {
+          Map<String, String> linkParameters = <String, String>{
+            CONTEXT_QUERY_PARAM: folder.path,
+            SOURCE_QUERY_PARAM: sourceUri
+          };
+          List<ResultDescriptor> results = entry.nonInvalidResults;
+          results.sort((ResultDescriptor first, ResultDescriptor second) =>
+              first.toString().compareTo(second.toString()));
 
-        buffer.write('<h3>Library Independent</h3>');
-        _writeDescriptorTable(buffer, entry.descriptors, entry.getState,
-            entry.getValue, linkParameters);
-        if (entry is DartEntry) {
-          for (Source librarySource in entry.containingLibraries) {
-            String libraryName = HTML_ESCAPE.convert(librarySource.fullName);
-            buffer.write('<h3>In library $libraryName:</h3>');
-            _writeDescriptorTable(buffer, entry.libraryDescriptors,
-                (DataDescriptor descriptor) =>
-                    entry.getStateInLibrary(descriptor, librarySource),
-                (DataDescriptor descriptor) =>
-                    entry.getValueInLibrary(descriptor, librarySource),
-                linkParameters);
+          buffer.write('<h3>');
+          buffer.write(HTML_ESCAPE.convert(entry.target.toString()));
+          buffer.write('</h3>');
+          buffer.write('<dl>');
+          buffer.write('<dt>time</dt><dd>');
+          buffer.write(entry.modificationTime);
+          buffer.write('</dd></dl>');
+          for (ResultDescriptor result in results) {
+            ResultData data = entry.getResultData(result);
+            String descriptorName = HTML_ESCAPE.convert(result.toString());
+            String descriptorState = HTML_ESCAPE.convert(data.state.toString());
+            buffer.write('<dt>$descriptorName ($descriptorState)</dt><dd>');
+            try {
+              _writeValueAsHtml(buffer, data.value, linkParameters);
+            } catch (exception) {
+              buffer.write('(${HTML_ESCAPE.convert(exception.toString())})');
+            }
+            buffer.write('</dd>');
           }
-        }
-        if (entry.exception != null) {
-          buffer.write('<h3>Exception</h3>');
-          _writeException(buffer, entry.exception);
+          if (entry.exception != null) {
+            buffer.write('<dt>exception</dt><dd>');
+            _writeException(buffer, entry.exception);
+            buffer.write('</dd></dl>');
+          }
+          buffer.write('</dl>');
         }
       });
     });
   }
 
   /**
    * Return a response indicating the set of source files in a certain cache
    * state.
    */
   void _returnCacheState(HttpRequest request) {
@@ skipping 24 matching lines @@
           request, 'Query parameter $STATE_QUERY_PARAM is invalid');
     }
     // Figure out which descriptor is being searched for.
     String descriptorFilter =
         request.uri.queryParameters[DESCRIPTOR_QUERY_PARAM];
     if (descriptorFilter == null) {
       return _returnFailure(
           request, 'Query parameter $DESCRIPTOR_QUERY_PARAM required');
     }
 
-    Folder folder = _findFolder(analysisServer, contextFilter);
-    AnalysisContextImpl context = analysisServer.folderMap[folder];
-    List<String> links = <String>[];
-    context.visitCacheItems((Source source, SourceEntry dartEntry,
-        DataDescriptor rowDesc, CacheState state) {
-      if (state != stateFilter || rowDesc.toString() != descriptorFilter) {
-        return;
-      }
-      String link = makeLink(CACHE_ENTRY_PATH, {
-        CONTEXT_QUERY_PARAM: folder.path,
-        SOURCE_QUERY_PARAM: source.uri.toString()
-      }, HTML_ESCAPE.convert(source.fullName));
-      links.add(link);
-    });
+    // TODO(brianwilkerson) Figure out how to convert the 'descriptorFilter' to
+    // a ResultDescriptor so that we can query the state, then uncomment the
+    // code below that computes and prints the list of links.
+//    Folder folder = _findFolder(analysisServer, contextFilter);
+//    InternalAnalysisContext context = analysisServer.folderMap[folder];
+//    List<String> links = <String>[];
+//    MapIterator<AnalysisTarget, CacheEntry> iterator = context.analysisCache.iterator();
+//    while (iterator.moveNext()) {
+//      Source source = iterator.key.source;
+//      if (source != null) {
+//        CacheEntry entry = iterator.value;
+//        if (entry.getState(result) == stateFilter) {
+//          String link = makeLink(CACHE_ENTRY_PATH, {
+//            CONTEXT_QUERY_PARAM: folder.path,
+//            SOURCE_QUERY_PARAM: source.uri.toString()
+//          }, HTML_ESCAPE.convert(source.fullName));
+//          links.add(link);
+//        }
+//      }
+//    }
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Cache Search', [
         'Context: $contextFilter',
         'Descriptor: ${HTML_ESCAPE.convert(descriptorFilter)}',
         'State: ${HTML_ESCAPE.convert(stateQueryParam)}'
       ], (StringBuffer buffer) {
-        buffer.write('<p>${links.length} files found</p>');
-        buffer.write('<ul>');
-        links.forEach((String link) {
-          buffer.write('<li>$link</li>');
-        });
-        buffer.write('</ul>');
+        buffer.write('<p>Cache search is not yet implemented.</p>');
+//        buffer.write('<p>${links.length} files found</p>');
+//        buffer.write('<ul>');
+//        links.forEach((String link) {
+//          buffer.write('<li>$link</li>');
+//        });
+//        buffer.write('</ul>');
       });
     });
   }
 
   /**
    * Return a response displaying overall performance information.
    */
   void _returnCommunicationPerformance(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
@@ skipping 91 matching lines @@
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
       return _returnFailure(request, 'Invalid context: $contextFilter');
     }
 
     List<String> priorityNames;
     List<String> explicitNames = <String>[];
     List<String> implicitNames = <String>[];
     Map<String, String> links = new HashMap<String, String>();
     List<CaughtException> exceptions = <CaughtException>[];
-    AnalysisContextImpl context = analysisServer.folderMap[folder];
+    InternalAnalysisContext context = analysisServer.folderMap[folder];
     priorityNames = context.prioritySources
         .map((Source source) => source.fullName)
         .toList();
-    context.visitCacheItems((Source source, SourceEntry sourceEntry,
-        DataDescriptor rowDesc, CacheState state) {
-      String sourceName = source.fullName;
-      if (!links.containsKey(sourceName)) {
-        CaughtException exception = sourceEntry.exception;
-        if (exception != null) {
-          exceptions.add(exception);
+    MapIterator<AnalysisTarget, CacheEntry> iterator =
+        context.analysisCache.iterator();
+    while (iterator.moveNext()) {
+      Source source = iterator.key.source;
+      if (source != null) {
+        CacheEntry entry = iterator.value;
+        String sourceName = source.fullName;
+        if (!links.containsKey(sourceName)) {
+          CaughtException exception = entry.exception;
+          if (exception != null) {
+            exceptions.add(exception);
+          }
+          String link = makeLink(CACHE_ENTRY_PATH, {
+            CONTEXT_QUERY_PARAM: folder.path,
+            SOURCE_QUERY_PARAM: source.uri.toString()
+          }, sourceName, exception != null);
+          if (entry.explicitlyAdded) {
+            explicitNames.add(sourceName);
+          } else {
+            implicitNames.add(sourceName);
+          }
+          links[sourceName] = link;
         }
-        String link = makeLink(CACHE_ENTRY_PATH, {
-          CONTEXT_QUERY_PARAM: folder.path,
-          SOURCE_QUERY_PARAM: source.uri.toString()
-        }, sourceName, exception != null);
-        if (sourceEntry.explicitlyAdded) {
-          explicitNames.add(sourceName);
-        } else {
-          implicitNames.add(sourceName);
-        }
-        links[sourceName] = link;
       }
-    });
+    }
     explicitNames.sort();
     implicitNames.sort();
 
     _overlayContents.clear();
     context.visitContentCache((String fullName, int stamp, String contents) {
       _overlayContents[fullName] = contents;
     });
 
     void _writeFiles(
         StringBuffer buffer, String title, List<String> fileNames) {
@@ skipping 72 matching lines @@
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
       return _returnFailure(request, 'Invalid context: $contextFilter');
     }
     String sourceUri = request.uri.queryParameters[SOURCE_QUERY_PARAM];
     if (sourceUri == null) {
       return _returnFailure(
           request, 'Query parameter $SOURCE_QUERY_PARAM required');
     }
 
-    AnalysisContextImpl context = analysisServer.folderMap[folder];
+    InternalAnalysisContext context = analysisServer.folderMap[folder];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Element Model', [
         'Context: $contextFilter',
         'File: $sourceUri'
       ], (StringBuffer buffer) {
         Source source = context.sourceFactory.forUri(sourceUri);
         if (source == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
-        SourceEntry entry = context.getReadableSourceEntryOrNull(source);
+        CacheEntry entry = context.analysisCache.get(source);
         if (entry == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
-        LibraryElement element = entry.getValue(DartEntry.ELEMENT);
+        LibraryElement element = entry.getValue(LIBRARY_ELEMENT);
         if (element == null) {
           buffer.write('<p>null</p>');
           return;
         }
         element.accept(new ElementWriter(buffer));
       });
     });
   }
 
   void _returnFailure(HttpRequest request, String message) {
@@ skipping 325 matching lines @@
       <p><strong># Notifications</strong> - the total number of notifications
         sent to the client with completion results for this request.
       <p><strong># Suggestions</strong> - the number of suggestions
         sent to the client in the first notification, followed by a comma,
         followed by the number of suggestions send to the client
         in the last notification. If there is only one notification,
         then there will be only one number in this column.''');
   }
 
   /**
-   * Generate a table showing the cache values corresponding to the given
-   * [descriptors], using [getState] to get the cache state corresponding to
-   * each descriptor, and [getValue] to get the cached value corresponding to
-   * each descriptor.  Append the resulting HTML to the given [buffer]. The
-   * [linkParameters] will be used if the value is too large to be displayed on
-   * the current page and needs to be linked to a separate page.
-   */
-  void _writeDescriptorTable(StringBuffer buffer,
-      List<DataDescriptor> descriptors, CacheState getState(DataDescriptor),
-      dynamic getValue(DataDescriptor), Map<String, String> linkParameters) {
-    buffer.write('<dl>');
-    for (DataDescriptor descriptor in descriptors) {
-      String descriptorName = HTML_ESCAPE.convert(descriptor.toString());
-      String descriptorState =
-          HTML_ESCAPE.convert(getState(descriptor).toString());
-      buffer.write('<dt>$descriptorName ($descriptorState)</dt><dd>');
-      try {
-        _writeValueAsHtml(buffer, getValue(descriptor), linkParameters);
-      } catch (exception) {
-        buffer.write('(${HTML_ESCAPE.convert(exception.toString())})');
-      }
-      buffer.write('</dd>');
-    }
-    buffer.write('</dl>');
-  }
-
-  /**
    * Write the status of the edit domain (on the main status page) to the given
    * [buffer].
    */
   void _writeEditStatus(StringBuffer buffer) {
     buffer.write('<h3>Edit Domain</h3>');
     _writeTwoColumns(buffer, (StringBuffer buffer) {
       buffer.write('<p><b>Performance Data</b></p>');
       buffer.write('<p>');
       buffer.write(makeLink(COMPLETION_PATH, {}, 'Completion data'));
       buffer.write('</p>');
@@ skipping 402 matching lines @@
    */
   static String makeLink(
       String path, Map<String, String> params, String innerHtml,
       [bool hasError = false]) {
     Uri uri = new Uri(path: path, queryParameters: params);
     String href = HTML_ESCAPE.convert(uri.toString());
     String classAttribute = hasError ? ' class="error"' : '';
     return '<a href="$href"$classAttribute>$innerHtml</a>';
   }
 }