Status page diagnostics for elements and docs.

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.status.get_handler;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/domain_completion.dart';
 import 'package:analysis_server/src/domain_diagnostic.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/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:analysis_server/src/status/validator.dart';
 import 'package:analysis_server/src/utilities/average.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart' show AnalysisContextImpl;
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
@@ skipping 10 matching lines @@
 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);
 
+class ElementCounter extends RecursiveElementVisitor {
+  Map<Type, int> counts = new HashMap<Type, int>();
+  int elementsWithDocs = 0;
+  int totalDocSpan = 0;
+
+  void visit(Element element) {
+    SourceRange docRange = element.docRange;

[Brian Wilkerson, 2015/12/16 23:38:53]

I think you're about to remove this API. :-)

[pquitslund, 2015/12/16 23:46:42]

: ) Yep.  When I do, I was thinking we may still want to do something like:

    totalDocSpan += element.computeDocumentationComment()?.length() ?? 0;

in case we want to easily keep tracking doc size.

+    if (docRange != null) {
+      ++elementsWithDocs;
+      totalDocSpan += docRange.length;
+    }
+
+    Type type = element.runtimeType;
+    if (counts[type] == null) {
+      counts[type] = 1;
+    } else {
+      counts[type]++;
+    }
+  }
+
+  @override
+  visitClassElement(ClassElement element) {
+    visit(element);
+    super.visitClassElement(element);
+  }
+
+  @override
+  visitCompilationUnitElement(CompilationUnitElement element) {
+    visit(element);
+    super.visitCompilationUnitElement(element);
+  }
+
+  @override
+  visitConstructorElement(ConstructorElement element) {
+    visit(element);
+    super.visitConstructorElement(element);
+  }
+
+  @override
+  visitExportElement(ExportElement element) {
+    visit(element);
+    super.visitExportElement(element);
+  }
+
+  @override
+  visitFieldElement(FieldElement element) {
+    visit(element);
+    super.visitFieldElement(element);
+  }
+
+  @override
+  visitFieldFormalParameterElement(FieldFormalParameterElement element) {
+    visit(element);
+    super.visitFieldFormalParameterElement(element);
+  }
+
+  @override
+  visitFunctionElement(FunctionElement element) {
+    visit(element);
+    super.visitFunctionElement(element);
+  }
+
+  @override
+  visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
+    visit(element);
+    super.visitFunctionTypeAliasElement(element);
+  }
+
+  @override
+  visitImportElement(ImportElement element) {
+    visit(element);
+    super.visitImportElement(element);
+  }
+
+  @override
+  visitLabelElement(LabelElement element) {
+    visit(element);
+    super.visitLabelElement(element);
+  }
+
+  @override
+  visitLibraryElement(LibraryElement element) {
+    visit(element);
+    super.visitLibraryElement(element);
+  }
+
+  @override
+  visitLocalVariableElement(LocalVariableElement element) {
+    visit(element);
+    super.visitLocalVariableElement(element);
+  }
+
+  @override
+  visitMethodElement(MethodElement element) {
+    visit(element);
+    super.visitMethodElement(element);
+  }
+
+  @override
+  visitMultiplyDefinedElement(MultiplyDefinedElement element) {
+    visit(element);
+    super.visitMultiplyDefinedElement(element);
+  }
+
+  @override
+  visitParameterElement(ParameterElement element) {
+    visit(element);
+    super.visitParameterElement(element);
+  }
+
+  @override
+  visitPrefixElement(PrefixElement element) {
+    visit(element);
+    super.visitPrefixElement(element);
+  }
+
+  @override
+  visitPropertyAccessorElement(PropertyAccessorElement element) {
+    visit(element);
+    super.visitPropertyAccessorElement(element);
+  }
+
+  @override
+  visitTopLevelVariableElement(TopLevelVariableElement element) {
+    visit(element);
+    super.visitTopLevelVariableElement(element);
+  }
+
+  @override
+  visitTypeParameterElement(TypeParameterElement element) {
+    visit(element);
+    super.visitTypeParameterElement(element);
+  }
+}
+
 /**
  * Instances of the class [GetHandler] handle GET requests.
  */
 class GetHandler {
   /**
    * The path used to request overall performance information.
    */
   static const String ANALYSIS_PERFORMANCE_PATH = '/perf/analysis';
 
   /**
@@ skipping 1616 matching lines @@
     buffer.write('<p>getDiagnostic (last call): ');
     buffer.write(elapsedMs);
     buffer.write(' (ms)</p>');
     buffer.write('<p>getDiagnostic (rolling average): ');
     buffer.write(_diagnosticCallAverage.value);
     buffer.write(' (ms)</p>&nbsp;');
 
     var json = response.toJson()[Response.RESULT];
     List contexts = json['contexts'];
     contexts.sort((first, second) => first['name'].compareTo(second['name']));
+
+    // Track visited libraries.
+    Set<LibraryElement> libraries = new HashSet<LibraryElement>();
+
+    // Count SDK elements separately.
+    ElementCounter sdkCounter = new ElementCounter();
+
     for (var context in contexts) {
       buffer.write('<p><h3>');
       buffer.write(context['name']);
       buffer.write('</h3></p>');
       buffer.write('<p>explicitFileCount: ');
       buffer.write(context['explicitFileCount']);
       buffer.write('</p>');
       buffer.write('<p>implicitFileCount: ');
       buffer.write(context['implicitFileCount']);
       buffer.write('</p>');
       buffer.write('<p>workItemQueueLength: ');
       buffer.write(context['workItemQueueLength']);
       buffer.write('</p>');
-      buffer.write('<p>workItemQueueLengthAverage: ');
-      buffer.write(context['workItemQueueLengthAverage']);
-      buffer.write('</p>');
+
+      AnalysisServer server = _server.analysisServer;
+
+      if (server != null) {
+        Folder folder = _findFolder(server, context['name']);
+        InternalAnalysisContext ac = _server.analysisServer.folderMap[folder];
+        ElementCounter counter = new ElementCounter();
+
+        for (Source source in ac.librarySources) {
+          LibraryElement libraryElement = ac.getLibraryElement(source);
+          if (libraries.add(libraryElement)) {
+            if (libraryElement != null) {
+              if (libraryElement.isInSdk) {
+                libraryElement.accept(sdkCounter);
+              } else {
+                libraryElement.accept(counter);
+              }
+            }
+          }
+        }
+        buffer.write('<p>element count: ');
+        buffer.write(
+            counter.counts.values.fold(0, (prev, element) => prev + element));
+        buffer.write('</p>');
+        buffer.write('<p>  (w/docs): ');
+        buffer.write(counter.elementsWithDocs);
+        buffer.write('</p>');
+        buffer.write('<p>total doc span: ');
+        buffer.write(counter.totalDocSpan);
+        buffer.write('</p>');
+      }
     }
+
+    buffer.write('<p><h3>');
+    buffer.write('SDK');
+    buffer.write('</h3></p>');
+    buffer.write('<p>element count: ');
+    buffer.write(
+        sdkCounter.counts.values.fold(0, (prev, element) => prev + element));
+    buffer.write('</p>');
+    buffer.write('<p>  (w/docs): ');
+    buffer.write(sdkCounter.elementsWithDocs);
+    buffer.write('</p>');
+    buffer.write('<p>total doc span: ');
+    buffer.write(sdkCounter.totalDocSpan);
+    buffer.write('</p>');
   }
 
   /**
    * 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>');
@@ skipping 491 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>';
   }
 }