Implementation of 'edit.organizeDirectives'.

pkg/analysis_server/lib/src/protocol.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 protocol;
 
 import 'dart:collection';
 import 'dart:convert';
 
 part 'generated_protocol.dart';
@@ skipping 374 matching lines @@
    */
   Object _decodeUnion(String jsonPath, Map json, String field,
       Map<String, JsonDecoderCallback> decoders) {
     if (json is Map) {
       if (!json.containsKey(field)) {
         throw missingKey(jsonPath, field);
       }
       var disambiguatorPath = '$jsonPath[${JSON.encode(field)}]';
       String disambiguator = _decodeString(disambiguatorPath, json[field]);
       if (!decoders.containsKey(disambiguator)) {
-        throw mismatch(disambiguatorPath, 'One of: ${decoders.keys.toList()}', json);
+        throw mismatch(
+            disambiguatorPath, 'One of: ${decoders.keys.toList()}', json);
       }
       return decoders[disambiguator](jsonPath, json);
     } else {
       throw mismatch(jsonPath, 'Map', json);
     }
   }
 }
 
 /**
  * Instances of the class [Notification] represent a notification from the
@@ skipping 212 matching lines @@
   @override
   dynamic mismatch(String jsonPath, String expected, [Object actual]) {
     StringBuffer buffer = new StringBuffer();
     buffer.write('Expected to be ');
     buffer.write(expected);
     if (actual != null) {
       buffer.write('; found "');
       buffer.write(JSON.encode(actual));
       buffer.write('"');
     }
-    return new RequestFailure(new Response.invalidParameter(
-        _request, jsonPath, buffer.toString()));
+    return new RequestFailure(
+        new Response.invalidParameter(_request, jsonPath, buffer.toString()));
   }
 
   @override
   dynamic missingKey(String jsonPath, String key) {
     return new RequestFailure(new Response.invalidParameter(
         _request, jsonPath, 'Expected to contain key ${JSON.encode(key)}'));
   }
 }
 
 /**
@@ skipping 74 matching lines @@
   /**
    * Initialize a newly created instance to represent a response to a request
    * with the given [id].  If [_result] is provided, it will be used as the
    * result; otherwise an empty result will be used.  If an [error] is provided
    * then the response will represent an error condition.
    */
   Response(this.id, {Map<String, Object> result, this.error})
       : _result = result;
 
   /**
+   * Initialize a newly created instance to represent the
+   * FILE_NOT_ANALYZED error condition.
+   */
+  Response.fileNotAnalyzed(Request request, String file)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.FILE_NOT_ANALYZED,
+                'File is not analyzed: $file.'));
+
+  /**
    * Initialize a newly created instance to represent the FORMAT_INVALID_FILE
    * error condition.
    */
-  Response.formatInvalidFile(Request request) : this(request.id,
-          error: new RequestError(RequestErrorCode.FORMAT_INVALID_FILE,
-              'Error during `edit.format`: invalid file.'));
+  Response.formatInvalidFile(Request request)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.FORMAT_INVALID_FILE,
+                'Error during `edit.format`: invalid file.'));
 
   /**
    * Initialize a newly created instance to represent the FORMAT_WITH_ERROR
    * error condition.
    */
-  Response.formatWithErrors(Request request) : this(request.id,
-          error: new RequestError(RequestErrorCode.FORMAT_WITH_ERRORS,
-              'Error during `edit.format`: source contains syntax errors.'));
+  Response.formatWithErrors(Request request)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.FORMAT_WITH_ERRORS,
+                'Error during `edit.format`: source contains syntax errors.'));
 
   /**
    * Initialize a newly created instance based upon the given JSON data
    */
   factory Response.fromJson(Map<String, Object> json) {
     try {
       Object id = json[Response.ID];
       if (id is! String) {
         return null;
       }
@@ skipping 11 matching lines @@
       return new Response(id, error: decodedError, result: decodedResult);
     } catch (exception) {
       return null;
     }
   }
 
   /**
    * Initialize a newly created instance to represent the
    * GET_ERRORS_INVALID_FILE error condition.
    */
-  Response.getErrorsInvalidFile(Request request) : this(request.id,
-          error: new RequestError(RequestErrorCode.GET_ERRORS_INVALID_FILE,
-              'Error during `analysis.getErrors`: invalid file.'));
+  Response.getErrorsInvalidFile(Request request)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.GET_ERRORS_INVALID_FILE,
+                'Error during `analysis.getErrors`: invalid file.'));
 
   /**
    * Initialize a newly created instance to represent the
    * GET_NAVIGATION_INVALID_FILE error condition.
    */
-  Response.getNavigationInvalidFile(Request request) : this(request.id,
-          error: new RequestError(RequestErrorCode.GET_NAVIGATION_INVALID_FILE,
-              'Error during `analysis.getNavigation`: invalid file.'));
+  Response.getNavigationInvalidFile(Request request)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.GET_NAVIGATION_INVALID_FILE,
+                'Error during `analysis.getNavigation`: invalid file.'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by an analysis.reanalyze [request] that specifies an analysis root that is
    * not in the current list of analysis roots.
    */
-  Response.invalidAnalysisRoot(Request request, String rootPath) : this(
-          request.id,
-          error: new RequestError(RequestErrorCode.INVALID_ANALYSIS_ROOT,
-              "Invalid analysis root: $rootPath"));
+  Response.invalidAnalysisRoot(Request request, String rootPath)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.INVALID_ANALYSIS_ROOT,
+                "Invalid analysis root: $rootPath"));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] that specifies an execution context whose context root does
    * not exist.
    */
-  Response.invalidExecutionContext(Request request, String contextId) : this(
-          request.id,
-          error: new RequestError(RequestErrorCode.INVALID_EXECUTION_CONTEXT,
-              "Invalid execution context: $contextId"));
+  Response.invalidExecutionContext(Request request, String contextId)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.INVALID_EXECUTION_CONTEXT,
+                "Invalid execution context: $contextId"));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] that had invalid parameter.  [path] is the path to the
    * invalid parameter, in Javascript notation (e.g. "foo.bar" means that the
    * parameter "foo" contained a key "bar" whose value was the wrong type).
    * [expectation] is a description of the type of data that was expected.
    */
   Response.invalidParameter(Request request, String path, String expectation)
       : this(request.id,
-          error: new RequestError(RequestErrorCode.INVALID_PARAMETER,
-              "Invalid parameter '$path'. $expectation."));
+            error: new RequestError(RequestErrorCode.INVALID_PARAMETER,
+                "Invalid parameter '$path'. $expectation."));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a malformed request.
    */
-  Response.invalidRequestFormat() : this('',
-          error: new RequestError(
-              RequestErrorCode.INVALID_REQUEST, 'Invalid request'));
+  Response.invalidRequestFormat()
+      : this('',
+            error: new RequestError(
+                RequestErrorCode.INVALID_REQUEST, 'Invalid request'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a request that requires an index, but indexing is disabled.
    */
-  Response.noIndexGenerated(Request request) : this(request.id,
-          error: new RequestError(
-              RequestErrorCode.NO_INDEX_GENERATED, 'Indexing is disabled'));
+  Response.noIndexGenerated(Request request)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.NO_INDEX_GENERATED, 'Indexing is disabled'));
+
+  /**
+   * Initialize a newly created instance to represent the
+   * ORGANIZE_DIRECTIVES_ERROR error condition.
+   */
+  Response.organizeDirectivesError(Request request, String message)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.ORGANIZE_DIRECTIVES_ERROR, message));
 
   /**
    * Initialize a newly created instance to represent the
    * REFACTORING_REQUEST_CANCELLED error condition.
    */
-  Response.refactoringRequestCancelled(Request request) : this(request.id,
-          error: new RequestError(
-              RequestErrorCode.REFACTORING_REQUEST_CANCELLED,
-              'The `edit.getRefactoring` request was cancelled.'));
+  Response.refactoringRequestCancelled(Request request)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.REFACTORING_REQUEST_CANCELLED,
+                'The `edit.getRefactoring` request was cancelled.'));
 
   /**
    * Initialize a newly created instance to represent the SERVER_ERROR error
    * condition.
    */
   factory Response.serverError(Request request, exception, stackTrace) {
     RequestError error =
         new RequestError(RequestErrorCode.SERVER_ERROR, exception.toString());
     if (stackTrace != null) {
       error.stackTrace = stackTrace.toString();
     }
     return new Response(request.id, error: error);
   }
 
   /**
    * Initialize a newly created instance to represent the
    * SORT_MEMBERS_INVALID_FILE error condition.
    */
-  Response.sortMembersInvalidFile(Request request) : this(request.id,
-          error: new RequestError(RequestErrorCode.SORT_MEMBERS_INVALID_FILE,
-              'Error during `edit.sortMembers`: invalid file.'));
+  Response.sortMembersInvalidFile(Request request)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.SORT_MEMBERS_INVALID_FILE,
+                'Error during `edit.sortMembers`: invalid file.'));
 
   /**
    * Initialize a newly created instance to represent the
    * SORT_MEMBERS_PARSE_ERRORS error condition.
    */
-  Response.sortMembersParseErrors(Request request, int numErrors) : this(
-          request.id,
-          error: new RequestError(RequestErrorCode.SORT_MEMBERS_PARSE_ERRORS,
-              'Error during `edit.sortMembers`: file has $numErrors scan/parse errors.'));
+  Response.sortMembersParseErrors(Request request, int numErrors)
+      : this(request.id,
+            error: new RequestError(RequestErrorCode.SORT_MEMBERS_PARSE_ERRORS,
+                'Error during `edit.sortMembers`: file has $numErrors scan/parse errors.'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a `analysis.setPriorityFiles` [request] that includes one or more files
    * that are not being analyzed.
    */
-  Response.unanalyzedPriorityFiles(String requestId, String fileNames) : this(
-          requestId,
-          error: new RequestError(RequestErrorCode.UNANALYZED_PRIORITY_FILES,
-              "Unanalyzed files cannot be a priority: '$fileNames'"));
+  Response.unanalyzedPriorityFiles(String requestId, String fileNames)
+      : this(requestId,
+            error: new RequestError(RequestErrorCode.UNANALYZED_PRIORITY_FILES,
+                "Unanalyzed files cannot be a priority: '$fileNames'"));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] that cannot be handled by any known handlers.
    */
-  Response.unknownRequest(Request request) : this(request.id,
-          error: new RequestError(
-              RequestErrorCode.UNKNOWN_REQUEST, 'Unknown request'));
+  Response.unknownRequest(Request request)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.UNKNOWN_REQUEST, 'Unknown request'));
 
   /**
    * Initialize a newly created instance to represent an error condition caused
    * by a [request] referencing a source that does not exist.
    */
-  Response.unknownSource(Request request) : this(request.id,
-          error: new RequestError(
-              RequestErrorCode.UNKNOWN_SOURCE, 'Unknown source'));
+  Response.unknownSource(Request request)
+      : this(request.id,
+            error: new RequestError(
+                RequestErrorCode.UNKNOWN_SOURCE, 'Unknown source'));
 
-  Response.unsupportedFeature(String requestId, String message) : this(
-          requestId,
-          error: new RequestError(
-              RequestErrorCode.UNSUPPORTED_FEATURE, message));
+  Response.unsupportedFeature(String requestId, String message)
+      : this(requestId,
+            error: new RequestError(
+                RequestErrorCode.UNSUPPORTED_FEATURE, message));
 
   /**
    * Return a table representing the structure of the Json object that will be
    * sent to the client to represent this response.
    */
   Map<String, Object> toJson() {
     Map<String, Object> jsonObject = new HashMap<String, Object>();
     jsonObject[ID] = id;
     if (error != null) {
       jsonObject[ERROR] = error.toJson();
@@ skipping 52 matching lines @@
     hash = 0x1fffffff & (hash + ((0x03ffffff & hash) << 3));
     hash = hash ^ (hash >> 11);
     return 0x1fffffff & (hash + ((0x00003fff & hash) << 15));
   }
 
   static int hash2(a, b) => finish(combine(combine(0, a), b));
 
   static int hash4(a, b, c, d) =>
       finish(combine(combine(combine(combine(0, a), b), c), d));
 }