Add links to context information for SDK contexts

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:collection';
 import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
@@ skipping 382 matching lines @@
     } else if (path == OVERLAY_PATH) {
       _returnOverlayContents(request);
     } else if (path == OVERLAYS_PATH) {
       _returnOverlaysInfo(request);
     } else {
       _returnUnknownRequest(request);
     }
   }
 
   /**
+   * Produce an encoded version of the given [descriptor] that can be used to
+   * find the descriptor later.
+   */
+  String _encodeSdkDescriptor(SdkDescription descriptor) {
+    StringBuffer buffer = new StringBuffer();
+    buffer.write(descriptor.options.encodeCrossContextOptions());
+    for (String path in descriptor.paths) {
+      buffer.write('+');
+      buffer.write(path);
+    }
+    return buffer.toString();
+  }
+
+  /**
    * 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);
   }
 
   /**
@@ skipping 142 matching lines @@
         results.add(INFERABLE_STATIC_VARIABLE_DEPENDENCIES);
         results.add(INFERRED_STATIC_VARIABLE);
       }
     } else if (target is AnalysisContextTarget) {
       results.add(TYPE_PROVIDER);
     }
     return results.toList();
   }
 
   /**
+   * Return the context for the SDK whose descriptor is encoded to be the same
+   * as the given [contextFilter]. The [analysisServer] is used to access the
+   * SDKs.
+   */
+  AnalysisContext _getSdkContext(
+      AnalysisServer analysisServer, String contextFilter) {
+    DartSdkManager manager = analysisServer.sdkManager;
+    List<SdkDescription> descriptors = manager.sdkDescriptors;
+    for (SdkDescription descriptor in descriptors) {
+      if (contextFilter == _encodeSdkDescriptor(descriptor)) {
+        return manager.getSdk(descriptor, () => null)?.context;
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return `true` if the given analysis [context] has at least one entry with
    * an exception.
    */
   bool _hasException(InternalAnalysisContext context) {
+    if (context == null) {
+      return false;
+    }
     MapIterator<AnalysisTarget, CacheEntry> iterator =
         context.analysisCache.iterator();
     while (iterator.moveNext()) {
       CacheEntry entry = iterator.value;
       if (entry == null || entry.exception != null) {
         return true;
       }
     }
     return false;
   }
@@ skipping 316 matching lines @@
   void _returnCacheEntry(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server not running');
     }
     String contextFilter = request.uri.queryParameters[CONTEXT_QUERY_PARAM];
     if (contextFilter == null) {
       return _returnFailure(
           request, 'Query parameter $CONTEXT_QUERY_PARAM required');
     }
+    InternalAnalysisContext context = null;
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
-      return _returnFailure(request, 'Invalid context: $contextFilter');
+      context = _getSdkContext(analysisServer, contextFilter);
+      if (context == null) {
+        return _returnFailure(request, 'Invalid context: $contextFilter');
+      }
+      return _returnFailure(request,
+          'Cannot view cache entries from an SDK context: $contextFilter');
+    } else {
+      context = analysisServer.folderMap[folder];
     }
     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, List<CacheEntry>> entryMap =
         new HashMap<Folder, List<CacheEntry>>();
@@ skipping 21 matching lines @@
               invalidKeysBuffer.write(iterator.key.toString());
             } else {
               entries.add(value);
             }
           }
         }
       }
     });
     allContexts.sort((Folder firstFolder, Folder secondFolder) =>
         firstFolder.path.compareTo(secondFolder.path));
-    InternalAnalysisContext context = analysisServer.folderMap[folder];
 
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Cache Entry',
           ['Context: $contextFilter', 'File: $sourceUri'], (HttpResponse) {
         if (invalidKeysBuffer.isNotEmpty) {
           buffer.write('<h3>Targets with null Entries</h3><p>');
           buffer.write(invalidKeysBuffer.toString());
           buffer.write('</p>');
         }
         List<CacheEntry> entries = entryMap[folder];
@@ skipping 33 matching lines @@
           }
         });
         buffer.write('</p>');
 
         if (entries == null) {
           buffer.write('<p>Not being analyzed in this context.</p>');
           return;
         }
         for (CacheEntry entry in entries) {
           Map<String, String> linkParameters = <String, String>{
-            CONTEXT_QUERY_PARAM: folder.path,
+            CONTEXT_QUERY_PARAM: contextFilter,
             SOURCE_QUERY_PARAM: sourceUri
           };
           List<ResultDescriptor> results = _getExpectedResults(entry);
           results.sort(ResultDescriptor.SORT_BY_NAME);
 
           buffer.write('<h3>');
           buffer.write(HTML_ESCAPE.convert(entry.target.toString()));
           buffer.write('</h3>');
           buffer.write('<p>time</p><blockquote><p>Value</p><blockquote>');
           buffer.write(entry.modificationTime);
@@ skipping 196 matching lines @@
   void _returnContextDiagnostics(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
     String contextFilter = request.uri.queryParameters[CONTEXT_QUERY_PARAM];
     if (contextFilter == null) {
       return _returnFailure(
           request, 'Query parameter $CONTEXT_QUERY_PARAM required');
     }
+    InternalAnalysisContext context = null;
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
-      return _returnFailure(request, 'Invalid context: $contextFilter');
+      context = _getSdkContext(analysisServer, contextFilter);
+      if (context == null) {
+        return _returnFailure(request, 'Invalid context: $contextFilter');
+      }
+    } else {
+      context = analysisServer.folderMap[folder];
     }
 
-    InternalAnalysisContext context = analysisServer.folderMap[folder];
-
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Context Diagnostics',
           ['Context: $contextFilter'], (StringBuffer buffer) {
-        _writeContextDiagnostics(buffer, context);
+        _writeContextDiagnostics(buffer, context, contextFilter);
       });
     });
   }
 
   /**
    * Return a response containing information about a single source file in the
    * cache.
    */
   void _returnContextInfo(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server not running');
     }
     String contextFilter = request.uri.queryParameters[CONTEXT_QUERY_PARAM];
     if (contextFilter == null) {
       return _returnFailure(
           request, 'Query parameter $CONTEXT_QUERY_PARAM required');
     }
+    InternalAnalysisContext context = null;
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
-      return _returnFailure(request, 'Invalid context: $contextFilter');
+      context = _getSdkContext(analysisServer, contextFilter);
+      if (context == null) {
+        return _returnFailure(request, 'Invalid context: $contextFilter');
+      }
+    } else {
+      context = analysisServer.folderMap[folder];
     }
 
     List<String> priorityNames = <String>[];
     List<String> explicitNames = <String>[];
     List<String> implicitNames = <String>[];
     Map<String, String> links = new HashMap<String, String>();
     List<CaughtException> exceptions = <CaughtException>[];
-    InternalAnalysisContext context = analysisServer.folderMap[folder];
     context.prioritySources.forEach((Source source) {
       priorityNames.add(source.fullName);
     });
     MapIterator<AnalysisTarget, CacheEntry> iterator =
         context.analysisCache.iterator(context: context);
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
       if (target is Source) {
         CacheEntry entry = iterator.value;
         String sourceName = target.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,
+                CONTEXT_QUERY_PARAM: contextFilter,
                 SOURCE_QUERY_PARAM: target.uri.toString()
               },
               sourceName,
               exception != null);
           if (entry.explicitlyAdded) {
             explicitNames.add(sourceName);
           } else {
             implicitNames.add(sourceName);
           }
           links[sourceName] = link;
@@ skipping 37 matching lines @@
       buffer.write('<p>');
       _writeOption(
           buffer, 'Analyze functon bodies', options.analyzeFunctionBodies);
       _writeOption(buffer, 'Cache size', options.cacheSize);
       _writeOption(buffer, 'Enable async support', options.enableAsync);
       _writeOption(
           buffer, 'Enable generic methods', options.enableGenericMethods);
       _writeOption(
           buffer, 'Enable strict call checks', options.enableStrictCallChecks);
       _writeOption(buffer, 'Enable super mixins', options.enableSuperMixins);
-      _writeOption(buffer, 'Enable trailing commas', options.enableTrailingCommas);
+      _writeOption(
+          buffer, 'Enable trailing commas', options.enableTrailingCommas);
       _writeOption(buffer, 'Generate dart2js hints', options.dart2jsHint);
       _writeOption(buffer, 'Generate errors in implicit files',
           options.generateImplicitErrors);
       _writeOption(
           buffer, 'Generate errors in SDK files', options.generateSdkErrors);
       _writeOption(buffer, 'Generate hints', options.hint);
       _writeOption(buffer, 'Incremental resolution', options.incremental);
       _writeOption(buffer, 'Incremental resolution with API changes',
           options.incrementalApi);
       _writeOption(buffer, 'Preserve comments', options.preserveComments);
@@ skipping 125 matching lines @@
   void _returnContextValidationDiagnostics(HttpRequest request) {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return _returnFailure(request, 'Analysis server is not running');
     }
     String contextFilter = request.uri.queryParameters[CONTEXT_QUERY_PARAM];
     if (contextFilter == null) {
       return _returnFailure(
           request, 'Query parameter $CONTEXT_QUERY_PARAM required');
     }
+    InternalAnalysisContext context = null;
     Folder folder = _findFolder(analysisServer, contextFilter);
     if (folder == null) {
-      return _returnFailure(request, 'Invalid context: $contextFilter');
+      context = _getSdkContext(analysisServer, contextFilter);
+      if (context == null) {
+        return _returnFailure(request, 'Invalid context: $contextFilter');
+      }
+    } else {
+      context = analysisServer.folderMap[folder];
     }
 
-    InternalAnalysisContext context = analysisServer.folderMap[folder];
-
     _writeResponse(request, (StringBuffer buffer) {
       _writePage(buffer, 'Analysis Server - Context Validation Diagnostics',
           ['Context: $contextFilter'], (StringBuffer buffer) {
         _writeContextValidationDiagnostics(buffer, context);
       });
     });
   }
 
   /**
    * Return a response displaying diagnostic information.
@@ skipping 216 matching lines @@
             {CONTEXT_QUERY_PARAM: folder.path}, 'diagnostics'));
         buffer.write(']</b></small>');
         if (!folder.getChild('.packages').exists) {
           buffer.write(' <small>[no .packages file]</small>');
         }
       });
       buffer.write('</p>');
       buffer.write('<p><b>SDK Contexts</b></p>');
       buffer.write('<p>');
       first = true;
-      List<String> descriptors = analysisServer.sdkManager.sdkDescriptors
-          .map((SdkDescription descriptor) => descriptor.toString())
-          .toList();
+      DartSdkManager manager = analysisServer.sdkManager;
+      List<SdkDescription> descriptors = manager.sdkDescriptors;
       if (descriptors.isEmpty) {
         buffer.write('none');
       } else {
-        descriptors.sort();
-        for (String descriptor in descriptors) {
+        Map<String, SdkDescription> sdkMap = <String, SdkDescription>{};
+        for (SdkDescription descriptor in descriptors) {
+          sdkMap[descriptor.toString()] = descriptor;
+        }
+        List<String> descriptorNames = sdkMap.keys.toList();
+        descriptorNames.sort();
+        for (String name in descriptorNames) {
           if (first) {
             first = false;
           } else {
             buffer.write('<br>');
           }
-          // TODO(brianwilkerson) Add a link to information about the contexts.
-          buffer.write(descriptor);
+          SdkDescription descriptor = sdkMap[name];
+          String contextId = _encodeSdkDescriptor(descriptor);
+          buffer.write(makeLink(
+              CONTEXT_PATH,
+              {CONTEXT_QUERY_PARAM: contextId},
+              name,
+              _hasException(manager.getSdk(descriptor, () => null)?.context)));
+          buffer.write(' <small><b>[');
+          buffer.write(makeLink(CONTEXT_DIAGNOSTICS_PATH,
+              {CONTEXT_QUERY_PARAM: contextId}, 'diagnostics'));
+          buffer.write(']</b></small>');
         }
       }
       buffer.write('</p>');
 
       int freq = AnalysisServer.performOperationDelayFrequency;
       String delay = freq > 0 ? '1 ms every $freq ms' : 'off';
 
       buffer.write('<p><b>Performance Data</b></p>');
       buffer.write('<p>Perform operation delay: $delay</p>');
       buffer.write('<p>');
@@ skipping 121 matching lines @@
         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.''');
   }
 
   /**
    * Write diagnostic information about the given [context] to the given
    * [buffer].
    */
-  void _writeContextDiagnostics(
-      StringBuffer buffer, InternalAnalysisContext context) {
+  void _writeContextDiagnostics(StringBuffer buffer,
+      InternalAnalysisContext context, String contextFilter) {
     AnalysisDriver driver = (context as AnalysisContextImpl).driver;
     List<WorkItem> workItems = driver.currentWorkOrder?.workItems;
 
     buffer.write('<p>');
     buffer.write(makeLink(CONTEXT_VALIDATION_DIAGNOSTICS_PATH,
-        {CONTEXT_QUERY_PARAM: context.name}, 'Run validation'));
+        {CONTEXT_QUERY_PARAM: contextFilter}, 'Run validation'));
     buffer.write('</p>');
 
     buffer.write('<h3>Most Recently Perfomed Tasks</h3>');
     AnalysisTask.LAST_TASKS.forEach((String description) {
       buffer.write('<p>');
       buffer.write(description);
       buffer.write('</p>');
     });
 
     void writeWorkItem(StringBuffer buffer, WorkItem item) {
@@ skipping 656 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>';
   }
 }