Implemented analysis.setPrioritySource

pkg/analysis_server/lib/src/domain_edit.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 domain.edit;
 
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol.dart';
@@ skipping 82 matching lines @@
     RequestDatum lengthDatum = request.getRequiredParameter(LENGTH);
     int length = lengthDatum.asInt();
     // TODO(brianwilkerson) implement
     return null;
   }
 
   Response getFixes(Request request) {
     // errors
     RequestDatum errorsDatum = request.getRequiredParameter(ERRORS);
     List<AnalysisError> errors = errorsDatum.asList((RequestDatum datum) {
-      return _createAnalysisError(datum);
+      return _createAnalysisError(request, datum);
     });
     // TODO(brianwilkerson) implement
     return null;
   }
 
   Response getRefactorings(Request request) {
     // file
     RequestDatum fileDatum = request.getRequiredParameter(FILE);
     String file = fileDatum.asString();
     // offset
     RequestDatum offsetDatum = request.getRequiredParameter(OFFSET);
     int offset = offsetDatum.asInt();
     // length
     RequestDatum lengthDatum = request.getRequiredParameter(LENGTH);
     int length = lengthDatum.asInt();
     // TODO(brianwilkerson) implement
     return null;
   }
 
   Response setRefactoringOptions(Request request) {
     // id
     RequestDatum idDatum = request.getRequiredParameter(ID);
     String id = idDatum.asString();
     // TODO(brianwilkerson) implement
     return null;
   }
 
-  AnalysisError _createAnalysisError(RequestDatum datum) {
-    // TODO(brianwilkerson) implement
+  /**
+   * Convert the given data from a request into an analysis error.
+   */
+  AnalysisError _createAnalysisError(Request request, RequestDatum datum) {
+    String file;
+    String errorCodeName;
+    int offset;
+    int length;
+    String message;
+    String correction;
+    datum.forEachMap((String key, RequestDatum value) {
+      if (key == FILE) {
+        file = value.asString();
+      } else if (key == ERROR_CODE) {
+        errorCodeName = value.asString();
+      } else if (key == OFFSET) {
+        offset = value.asInt();
+      } else if (key == LENGTH) {
+        length = value.asInt();
+      } else if (key == MESSAGE) {
+        message = value.asString();
+      } else if (key == CORRECTION) {
+        correction = value.asString();
+      }
+    });
+    if (file == null) {
+      throw new RequestFailure(
+          new Response.missingRequiredParameter(request, 'file'));
+    }
+    if (errorCodeName == null) {
+      throw new RequestFailure(
+          new Response.missingRequiredParameter(request, 'errorCode'));
+    }
+    if (offset == null) {
+      throw new RequestFailure(
+          new Response.missingRequiredParameter(request, 'offset'));
+    }
+    if (length == null) {
+      throw new RequestFailure(
+          new Response.missingRequiredParameter(request, 'length'));
+    }
+    if (message == null) {
+      throw new RequestFailure(
+          new Response.missingRequiredParameter(request, 'message'));
+    }

[Paul Berry, 2014/06/16 23:43:16]

RequestDatum was intended to make this sort of error handling logic unnecessary
(so that we don't accidentally leave out necessary error checks).  You should be
able to replace everything from datum.forEachMap() through here with this
instead:

  file = datum[FILE].asString();
  errorCodeName = datum[ERROR_CODE].asString();
  offset = datum[OFFSET].asInt();
  length = datum[LENGTH].asInt();
  message = datum[MESSAGE].asString();
  if (datum.hasKey(CORRECTION)) {
    correction = datum[CORRECTION].asString();
  }

Datum's operator[], asString(), and asInt() methods will do all of the necessary
error checking, and throw exceptions if the data wasn't present or had the wrong
type.  If no exception is thrown, you are guaranteed that every call to
asString() returned a string, and every call to asInt() returned an int.

[Brian Wilkerson, 2014/06/17 17:46:16]

Thanks! That's much cleaner.

+    ErrorCode errorCode = convertErrorCode(errorCodeName);
+    if (errorCode == null) {
+
+    }
+    // TODO(brianwilkerson) Implement this.
+//    return new AnalysisError.con2(
+//        server.sourceFromFile(file),
+//        offset,
+//        length,
+//        errorCode,
+//        null);
+    return null;
+  }
+
+  /**
+   * Return the error code corresponding to the given [errorCodeName], or `null`
+   * if the given name is not a valid error code.
+   */
+  ErrorCode convertErrorCode(String errorCodeName) {
+    // TODO(brianwilkerson) Implement this.
+//    Enum2 errorCode = Enum2.valueOf(AngularCode.values, errorCodeName);
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(CompileTimeErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(HintCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(HtmlWarningCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(ParserErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(PolymerCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(PubSuggestionCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(ResolverErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(ScannerErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(StaticTypeErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(StaticWarningErrorCode.values, errorCodeName);
+//    }
+//    if (errorCode == null) {
+//      errorCode = Enum2.valueOf(TodoCode.values, errorCodeName);
+//    }
+    return null;
   }
 }