Clarify type names in analysis server API.

pkg/analysis_server/lib/src/generated_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.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
 part of protocol;
 /**
@@ skipping 3342 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getFixes result
  *
  * {
- *   "fixes": List<ErrorFixes>
+ *   "fixes": List<AnalysisErrorFixes>
  * }
  */
 class EditGetFixesResult implements HasToJson {
   /**
    * The fixes that are available for each of the analysis errors. There is a
    * one-to-one correspondence between the analysis errors in the request and
    * the lists of changes in the response. In particular, it is always the case
    * that errors.length == fixes.length and that fixes[i] is the list of fixes
    * for the error in errors[i]. The list of changes corresponding to an error
    * can be empty if there are no fixes available for that error.
    */
-  List<ErrorFixes> fixes;
+  List<AnalysisErrorFixes> fixes;
 
   EditGetFixesResult(this.fixes);
 
   factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
-      List<ErrorFixes> fixes;
+      List<AnalysisErrorFixes> fixes;
       if (json.containsKey("fixes")) {
-        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new ErrorFixes.fromJson(jsonDecoder, jsonPath, json));
+        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
     return new EditGetFixesResult.fromJson(
         new ResponseDecoder(), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["fixes"] = fixes.map((ErrorFixes value) => value.toJson()).toList();
+    result["fixes"] = fixes.map((AnalysisErrorFixes value) => value.toJson()).toList();
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetFixesResult) {
-      return _listEqual(fixes, other.fixes, (ErrorFixes a, ErrorFixes b) => a == b);
+      return _listEqual(fixes, other.fixes, (AnalysisErrorFixes a, AnalysisErrorFixes b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
@@ skipping 918 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, 704418402);
     hash = _JenkinsSmiHash.combine(hash, content.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * AnalysisError
  *
  * {
- *   "severity": ErrorSeverity
- *   "type": ErrorType
+ *   "severity": AnalysisErrorSeverity
+ *   "type": AnalysisErrorType
  *   "location": Location
  *   "message": String
  *   "correction": optional String
  * }
  */
 class AnalysisError implements HasToJson {
   /**
    * Returns a list of AnalysisErrors correponding to the given list of Engine
    * errors.
    */
   static List<AnalysisError> listFromEngine(engine.LineInfo lineInfo, List<engine.AnalysisError> errors) =>
       _analysisErrorListFromEngine(lineInfo, errors);
 
   /**
    * The severity of the error.
    */
-  ErrorSeverity severity;
+  AnalysisErrorSeverity severity;
 
   /**
    * The type of the error.
    */
-  ErrorType type;
+  AnalysisErrorType type;
 
   /**
    * The location associated with the error.
    */
   Location location;
 
   /**
    * The message to be displayed for this error. The message should indicate
    * what is wrong with the code and why it is wrong.
    */
   String message;
 
   /**
    * The correction message to be displayed for this error. The correction
    * message should indicate how the user can fix the error. The field is
    * omitted if there is no correction message associated with the error code.
    */
   String correction;
 
   AnalysisError(this.severity, this.type, this.location, this.message, {this.correction});
 
   factory AnalysisError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
-      ErrorSeverity severity;
+      AnalysisErrorSeverity severity;
       if (json.containsKey("severity")) {
-        severity = new ErrorSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
+        severity = new AnalysisErrorSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "severity");
       }
-      ErrorType type;
+      AnalysisErrorType type;
       if (json.containsKey("type")) {
-        type = new ErrorType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
+        type = new AnalysisErrorType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "type");
       }
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "location");
       }
       String message;
@@ skipping 51 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, severity.hashCode);
     hash = _JenkinsSmiHash.combine(hash, type.hashCode);
     hash = _JenkinsSmiHash.combine(hash, location.hashCode);
     hash = _JenkinsSmiHash.combine(hash, message.hashCode);
     hash = _JenkinsSmiHash.combine(hash, correction.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
+ * AnalysisErrorFixes
+ *
+ * {
+ *   "error": AnalysisError
+ *   "fixes": List<SourceChange>
+ * }
+ */
+class AnalysisErrorFixes implements HasToJson {
+  /**
+   * The error with which the fixes are associated.
+   */
+  AnalysisError error;
+
+  /**
+   * The fixes associated with the error.
+   */
+  List<SourceChange> fixes;
+
+  AnalysisErrorFixes(this.error, {this.fixes}) {
+    if (fixes == null) {
+      fixes = <SourceChange>[];
+    }
+  }
+
+  factory AnalysisErrorFixes.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
+    if (json is Map) {
+      AnalysisError error;
+      if (json.containsKey("error")) {
+        error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", json["error"]);
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "error");
+      }
+      List<SourceChange> fixes;
+      if (json.containsKey("fixes")) {
+        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        throw jsonDecoder.missingKey(jsonPath, "fixes");
+      }
+      return new AnalysisErrorFixes(error, fixes: fixes);
+    } else {
+      throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes");
+    }
+  }
+
+  Map<String, dynamic> toJson() {
+    Map<String, dynamic> result = {};
+    result["error"] = error.toJson();
+    result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList();
+    return result;
+  }
+
+  /**
+   * Add a [Fix]
+   */
+  void addFix(Fix fix) {
+    fixes.add(fix.change);
+  }
+
+  @override
+  String toString() => JSON.encode(toJson());
+
+  @override
+  bool operator==(other) {
+    if (other is AnalysisErrorFixes) {
+      return error == other.error &&
+          _listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a == b);
+    }
+    return false;
+  }
+
+  @override
+  int get hashCode {
+    int hash = 0;
+    hash = _JenkinsSmiHash.combine(hash, error.hashCode);
+    hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
+    return _JenkinsSmiHash.finish(hash);
+  }
+}
+
+/**
+ * AnalysisErrorSeverity
+ *
+ * enum {
+ *   INFO
+ *   WARNING
+ *   ERROR
+ * }
+ */
+class AnalysisErrorSeverity {
+  static const INFO = const AnalysisErrorSeverity._("INFO");
+
+  static const WARNING = const AnalysisErrorSeverity._("WARNING");
+
+  static const ERROR = const AnalysisErrorSeverity._("ERROR");
+
+  final String name;
+
+  const AnalysisErrorSeverity._(this.name);
+
+  factory AnalysisErrorSeverity(String name) {
+    switch (name) {
+      case "INFO":
+        return INFO;
+      case "WARNING":
+        return WARNING;
+      case "ERROR":
+        return ERROR;
+    }
+    throw new Exception('Illegal enum value: $name');
+  }
+
+  factory AnalysisErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json is String) {
+      try {
+        return new AnalysisErrorSeverity(json);
+      } catch(_) {
+        // Fall through
+      }
+    }
+    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorSeverity");
+  }
+
+  @override
+  String toString() => "AnalysisErrorSeverity.$name";
+
+  String toJson() => name;
+}
+
+/**
+ * AnalysisErrorType
+ *
+ * enum {
+ *   COMPILE_TIME_ERROR
+ *   HINT
+ *   STATIC_TYPE_WARNING
+ *   STATIC_WARNING
+ *   SYNTACTIC_ERROR
+ *   TODO
+ * }
+ */
+class AnalysisErrorType {
+  static const COMPILE_TIME_ERROR = const AnalysisErrorType._("COMPILE_TIME_ERROR");
+
+  static const HINT = const AnalysisErrorType._("HINT");
+
+  static const STATIC_TYPE_WARNING = const AnalysisErrorType._("STATIC_TYPE_WARNING");
+
+  static const STATIC_WARNING = const AnalysisErrorType._("STATIC_WARNING");
+
+  static const SYNTACTIC_ERROR = const AnalysisErrorType._("SYNTACTIC_ERROR");
+
+  static const TODO = const AnalysisErrorType._("TODO");
+
+  final String name;
+
+  const AnalysisErrorType._(this.name);
+
+  factory AnalysisErrorType(String name) {
+    switch (name) {
+      case "COMPILE_TIME_ERROR":
+        return COMPILE_TIME_ERROR;
+      case "HINT":
+        return HINT;
+      case "STATIC_TYPE_WARNING":
+        return STATIC_TYPE_WARNING;
+      case "STATIC_WARNING":
+        return STATIC_WARNING;
+      case "SYNTACTIC_ERROR":
+        return SYNTACTIC_ERROR;
+      case "TODO":
+        return TODO;
+    }
+    throw new Exception('Illegal enum value: $name');
+  }
+
+  factory AnalysisErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json is String) {
+      try {
+        return new AnalysisErrorType(json);
+      } catch(_) {
+        // Fall through
+      }
+    }
+    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorType");
+  }
+
+  @override
+  String toString() => "AnalysisErrorType.$name";
+
+  String toJson() => name;
+}
+
+/**
  * AnalysisOptions
  *
  * {
  *   "enableAsync": optional bool
  *   "enableDeferredLoading": optional bool
  *   "enableEnums": optional bool
  *   "generateDart2jsHints": optional bool
  *   "generateHints": optional bool
  * }
  */
@@ skipping 1161 matching lines @@
   factory ElementKind.fromEngine(engine.ElementKind kind) =>
       _elementKindFromEngine(kind);
 
   @override
   String toString() => "ElementKind.$name";
 
   String toJson() => name;
 }
 
 /**
- * ErrorFixes
- *
- * {
- *   "error": AnalysisError
- *   "fixes": List<SourceChange>
- * }
- */
-class ErrorFixes implements HasToJson {
-  /**
-   * The error with which the fixes are associated.
-   */
-  AnalysisError error;
-
-  /**
-   * The fixes associated with the error.
-   */
-  List<SourceChange> fixes;
-
-  ErrorFixes(this.error, {this.fixes}) {
-    if (fixes == null) {
-      fixes = <SourceChange>[];
-    }
-  }
-
-  factory ErrorFixes.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
-    if (json == null) {
-      json = {};
-    }
-    if (json is Map) {
-      AnalysisError error;
-      if (json.containsKey("error")) {
-        error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", json["error"]);
-      } else {
-        throw jsonDecoder.missingKey(jsonPath, "error");
-      }
-      List<SourceChange> fixes;
-      if (json.containsKey("fixes")) {
-        fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
-      } else {
-        throw jsonDecoder.missingKey(jsonPath, "fixes");
-      }
-      return new ErrorFixes(error, fixes: fixes);
-    } else {
-      throw jsonDecoder.mismatch(jsonPath, "ErrorFixes");
-    }
-  }
-
-  Map<String, dynamic> toJson() {
-    Map<String, dynamic> result = {};
-    result["error"] = error.toJson();
-    result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList();
-    return result;
-  }
-
-  /**
-   * Add a [Fix]
-   */
-  void addFix(Fix fix) {
-    fixes.add(fix.change);
-  }
-
-  @override
-  String toString() => JSON.encode(toJson());
-
-  @override
-  bool operator==(other) {
-    if (other is ErrorFixes) {
-      return error == other.error &&
-          _listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a == b);
-    }
-    return false;
-  }
-
-  @override
-  int get hashCode {
-    int hash = 0;
-    hash = _JenkinsSmiHash.combine(hash, error.hashCode);
-    hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
-    return _JenkinsSmiHash.finish(hash);
-  }
-}
-
-/**
- * ErrorSeverity
- *
- * enum {
- *   INFO
- *   WARNING
- *   ERROR
- * }
- */
-class ErrorSeverity {
-  static const INFO = const ErrorSeverity._("INFO");
-
-  static const WARNING = const ErrorSeverity._("WARNING");
-
-  static const ERROR = const ErrorSeverity._("ERROR");
-
-  final String name;
-
-  const ErrorSeverity._(this.name);
-
-  factory ErrorSeverity(String name) {
-    switch (name) {
-      case "INFO":
-        return INFO;
-      case "WARNING":
-        return WARNING;
-      case "ERROR":
-        return ERROR;
-    }
-    throw new Exception('Illegal enum value: $name');
-  }
-
-  factory ErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
-    if (json is String) {
-      try {
-        return new ErrorSeverity(json);
-      } catch(_) {
-        // Fall through
-      }
-    }
-    throw jsonDecoder.mismatch(jsonPath, "ErrorSeverity");
-  }
-
-  @override
-  String toString() => "ErrorSeverity.$name";
-
-  String toJson() => name;
-}
-
-/**
- * ErrorType
- *
- * enum {
- *   COMPILE_TIME_ERROR
- *   HINT
- *   STATIC_TYPE_WARNING
- *   STATIC_WARNING
- *   SYNTACTIC_ERROR
- *   TODO
- * }
- */
-class ErrorType {
-  static const COMPILE_TIME_ERROR = const ErrorType._("COMPILE_TIME_ERROR");
-
-  static const HINT = const ErrorType._("HINT");
-
-  static const STATIC_TYPE_WARNING = const ErrorType._("STATIC_TYPE_WARNING");
-
-  static const STATIC_WARNING = const ErrorType._("STATIC_WARNING");
-
-  static const SYNTACTIC_ERROR = const ErrorType._("SYNTACTIC_ERROR");
-
-  static const TODO = const ErrorType._("TODO");
-
-  final String name;
-
-  const ErrorType._(this.name);
-
-  factory ErrorType(String name) {
-    switch (name) {
-      case "COMPILE_TIME_ERROR":
-        return COMPILE_TIME_ERROR;
-      case "HINT":
-        return HINT;
-      case "STATIC_TYPE_WARNING":
-        return STATIC_TYPE_WARNING;
-      case "STATIC_WARNING":
-        return STATIC_WARNING;
-      case "SYNTACTIC_ERROR":
-        return SYNTACTIC_ERROR;
-      case "TODO":
-        return TODO;
-    }
-    throw new Exception('Illegal enum value: $name');
-  }
-
-  factory ErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
-    if (json is String) {
-      try {
-        return new ErrorType(json);
-      } catch(_) {
-        // Fall through
-      }
-    }
-    throw jsonDecoder.mismatch(jsonPath, "ErrorType");
-  }
-
-  @override
-  String toString() => "ErrorType.$name";
-
-  String toJson() => name;
-}
-
-/**
  * ExecutableFile
  *
  * {
  *   "file": FilePath
  *   "offset": ExecutableKind
  * }
  */
 class ExecutableFile implements HasToJson {
   /**
    * The path of the executable file.
@@ skipping 3887 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }