Reformat code to minimize churn

pkg/analysis_server/lib/src/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;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 156 matching lines @@
   /**
    * Return the active [CompletionDomainHandler]
    * or `null` if either analysis server is not running
    * or there is no completion domain handler.
    */
   CompletionDomainHandler get _completionDomainHandler {
     AnalysisServer analysisServer = _server.analysisServer;
     if (analysisServer == null) {
       return null;
     }
-    return analysisServer.handlers.firstWhere(
-        (h) => h is CompletionDomainHandler, orElse: () => null);
+    return analysisServer.handlers
+        .firstWhere((h) => h is CompletionDomainHandler, orElse: () => null);
   }
 
   /**
    * Handle a GET request received by the HTTP server.
    */
   void handleGetRequest(HttpRequest request) {
     String path = request.uri.path;
     if (path == STATUS_PATH) {
       _returnServerStatus(request);
     } else if (path == ANALYSIS_PERFORMANCE_PATH) {
@@ skipping 22 matching lines @@
       _returnUnknownRequest(request);
     }
   }
 
   /**
    * 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);
+        (Folder folder) => folder.path == contextFilter,
+        orElse: () => null);
   }
 
   /**
    * 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) {
@@ skipping 60 matching lines @@
           buffer.write('</table>');
         }
 
         //
         // Write new task model timing information.
         //
         if (AnalysisEngine.instance.useTaskModel) {
           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);
+          _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;
           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;
             totalTime += taskTime;
             _writeRow(buffer, [
               taskClass.toString(),
               count,
               taskTime,
               count <= 0 ? '-' : (taskTime / count).toStringAsFixed(3)
-            ], classes: [null, "right", "right", "right"]);
+            ], classes: [
+              null,
+              "right",
+              "right",
+              "right"
+            ]);
           });
           _writeRow(buffer, ['Total', '-', totalTime, '-'],
               classes: [null, "right", "right", "right"]);
           buffer.write('</table>');
         }
 
         //
         // Write old task model transition information.
         //
         {
@@ skipping 47 matching lines @@
     }
     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];
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - AST Structure', [
-        'Context: $contextFilter',
-        'File: $sourceUri'
-      ], (HttpResponse) {
+      _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);
         if (entry == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
@@ skipping 49 matching lines @@
           allContexts.add(folder);
           entryMap[folder] = entry;
         }
       }
     });
     allContexts.sort((Folder firstFolder, Folder secondFolder) =>
         firstFolder.path.compareTo(secondFolder.path));
     AnalysisContextImpl context = analysisServer.folderMap[folder];
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Cache Entry', [
-        'Context: $contextFilter',
-        'File: $sourceUri'
-      ], (HttpResponse) {
+      _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 =
               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)));
+            buffer.write(makeLink(
+                CACHE_ENTRY_PATH,
+                {
+                  CONTEXT_QUERY_PARAM: folder.path,
+                  SOURCE_QUERY_PARAM: sourceUri
+                },
+                HTML_ESCAPE.convert(folder.path)));
           }
           if (entryMap[folder].explicitlyAdded) {
             buffer.write(' (explicit)');
           } else {
             buffer.write(' (implicit)');
           }
         });
         buffer.write('</p>');
 
         SourceEntry entry = entryMap[folder];
         if (entry == 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
         };
 
         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,
+            _writeDescriptorTable(
+                buffer,
+                entry.libraryDescriptors,
                 (DataDescriptor descriptor) =>
                     entry.getStateInLibrary(descriptor, librarySource),
                 (DataDescriptor descriptor) =>
                     entry.getValueInLibrary(descriptor, librarySource),
                 linkParameters);
           }
         }
         if (entry.exception != null) {
           buffer.write('<h3>Exception</h3>');
           _writeException(buffer, entry.exception);
@@ skipping 42 matching lines @@
     }
 
     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));
+      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>');
@@ skipping 118 matching lines @@
         .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);
         }
-        String link = makeLink(CACHE_ENTRY_PATH, {
-          CONTEXT_QUERY_PARAM: folder.path,
-          SOURCE_QUERY_PARAM: source.uri.toString()
-        }, sourceName, exception != null);
+        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();
@@ skipping 18 matching lines @@
             buffer.write(
                 makeLink(OVERLAY_PATH, {PATH_PARAM: fileName}, 'overlay'));
           }
           buffer.write('</td></tr>');
         }
         buffer.write('</table>');
       }
     }
 
     _writeResponse(request, (StringBuffer buffer) {
-      _writePage(buffer, 'Analysis Server - Context',
-          ['Context: $contextFilter'], (StringBuffer buffer) {
+      _writePage(
+          buffer, 'Analysis Server - Context', ['Context: $contextFilter'],
+          (StringBuffer buffer) {
         List headerRowText = ['Context'];
         headerRowText.addAll(CacheState.values);
         buffer.write('<h3>Summary</h3>');
         buffer.write('<table>');
         _writeRow(buffer, headerRowText, header: true);
         AnalysisContextStatistics statistics = context.statistics;
         statistics.cacheRows.forEach((AnalysisContextStatistics_CacheRow row) {
           List rowText = [row.name];
           for (CacheState state in CacheState.values) {
             String text = row.getCount(state).toString();
@@ skipping 103 matching lines @@
     }
     if (index is LocalIndex) {
       Map<List<String>, List<InspectLocation>> relations =
           await index.findElementsByName(name);
       _writeResponse(request, (StringBuffer buffer) {
         _writePage(buffer, 'Analysis Server - Index Elements', ['Name: $name'],
             (StringBuffer buffer) {
           buffer.write('<table border="1">');
           _writeRow(buffer, ['Element', 'Relationship', 'Location'],
               header: true);
-          relations.forEach((List<String> elementPath,
-              List<InspectLocation> relations) {
+          relations.forEach(
+              (List<String> elementPath, List<InspectLocation> relations) {
             String elementLocation = elementPath.join(' ');
             relations.forEach((InspectLocation location) {
               var relString = location.relationship.identifier;
               var locString = '${location.path} offset=${location.offset} '
                   'length=${location.length} flags=${location.flags}';
               _writeRow(buffer, [elementLocation, relString, locString]);
             });
           });
           buffer.write('</table>');
         });
@@ skipping 135 matching lines @@
       buffer.write('<p><b>Analysis Contexts</b></p>');
       buffer.write('<p>');
       bool first = true;
       folders.forEach((Folder folder) {
         if (first) {
           first = false;
         } else {
           buffer.write('<br>');
         }
         String key = folder.shortName;
-        buffer.write(makeLink(CONTEXT_PATH, {
-          CONTEXT_QUERY_PARAM: folder.path
-        }, key, _hasException(folderMap[folder])));
+        buffer.write(makeLink(CONTEXT_PATH, {CONTEXT_QUERY_PARAM: folder.path},
+            key, _hasException(folderMap[folder])));
       });
       buffer.write('</p>');
 
       buffer.write('<p><b>Options</b></p>');
       buffer.write('<p>');
       _writeOption(
           buffer, 'Analyze functon bodies', options.analyzeFunctionBodies);
       _writeOption(buffer, 'Cache size', options.cacheSize);
       _writeOption(
           buffer, 'Enable strict call checks', options.enableStrictCallChecks);
@@ skipping 66 matching lines @@
    * Write a table showing summary information for the last several
    * completion requests to the given [buffer] object.
    */
   void _writeCompletionPerformanceList(StringBuffer buffer) {
     CompletionDomainHandler handler = _completionDomainHandler;
     buffer.write('<h3>Completion Performance List</h3>');
     if (handler == null) {
       return;
     }
     buffer.write('<table>');
-    _writeRow(buffer, [
-      'Start Time',
-      '',
-      'First (ms)',
-      '',
-      'Complete (ms)',
-      '',
-      '# Notifications',
-      '',
-      '# Suggestions',
-      '',
-      'Snippet'
-    ], header: true);
+    _writeRow(
+        buffer,
+        [
+          'Start Time',
+          '',
+          'First (ms)',
+          '',
+          'Complete (ms)',
+          '',
+          '# Notifications',
+          '',
+          '# Suggestions',
+          '',
+          'Snippet'
+        ],
+        header: true);
     int index = 0;
     for (CompletionPerformance performance in handler.performanceList) {
-      String link = makeLink(COMPLETION_PATH, {
-        'index': '$index'
-      }, '${performance.startTimeAndMs}');
+      String link = makeLink(COMPLETION_PATH, {'index': '$index'},
+          '${performance.startTimeAndMs}');
       _writeRow(buffer, [
         link,
         '&nbsp;&nbsp;',
         performance.firstNotificationInMilliseconds,
         '&nbsp;&nbsp;',
         performance.elapsedInMilliseconds,
         '&nbsp;&nbsp;',
         performance.notificationCount,
         '&nbsp;&nbsp;',
         performance.suggestionCount,
@@ skipping 21 matching lines @@
   }
 
   /**
    * 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) {
+  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())})');
@@ skipping 419 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>';
   }
 }