Reformat code to minimize churn

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';
@@ skipping 161 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 any AST structure stored in the given [entry].
    */
   CompilationUnit _getAnyAst(CacheEntry entry) {
     CompilationUnit unit = entry.getValue(PARSED_UNIT);
     if (unit != null) {
       return unit;
     }
@@ skipping 98 matching lines @@
               classes: ["right", "right", null]);
         }
         tags.forEach(writeRow);
         buffer.write('</table>');
         //
         // Write task model timing information.
         //
         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 = 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 totalTaskTime = 0;
         taskClasses.forEach((Type taskClass) {
           int count = countMap[taskClass];
           if (count == null) {
             count = 0;
           }
           int taskTime = stopwatchMap[taskClass].elapsedMilliseconds;
           totalTaskTime += 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', '-', totalTaskTime, '-'],
             classes: [null, "right", "right", "right"]);
         buffer.write('</table>');
       });
     });
   }
 
   /**
    * Return a response containing information about an AST structure.
@@ skipping 14 matching lines @@
     }
     String sourceUri = request.uri.queryParameters[SOURCE_QUERY_PARAM];
     if (sourceUri == null) {
       return _returnFailure(
           request, 'Query parameter $SOURCE_QUERY_PARAM required');
     }
 
     InternalAnalysisContext 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;
         }
         CacheEntry entry = context.analysisCache.get(source);
         if (entry == null) {
           buffer.write('<p>Not found.</p>');
           return;
         }
@@ skipping 60 matching lines @@
             entries.add(iterator.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) {
+      _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>');
           }
           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)));
+            buffer.write(makeLink(
+                CACHE_ENTRY_PATH,
+                {
+                  CONTEXT_QUERY_PARAM: folder.path,
+                  SOURCE_QUERY_PARAM: sourceUri
+                },
+                HTML_ESCAPE.convert(folder.path)));
           }
           if (entryMap[folder][0].explicitlyAdded) {
             buffer.write(' (explicit)');
           } else {
             buffer.write(' (implicit)');
           }
         });
         buffer.write('</p>');
 
         List<CacheEntry> entries = entryMap[folder];
@@ skipping 233 matching lines @@
     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);
+          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;
         }
       }
     }
     explicitNames.sort();
@@ skipping 19 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 436 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>';
   }
 }