Analysis server code generation improvements

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 protocol2;
 
 /**
  * server.getVersion result
  *
  * {
  *   "version": String
  * }
  */
-class ServerGetVersionResult {
+class ServerGetVersionResult implements HasToJson {
   /**
    * The version number of the analysis server.
    */
   final String version;
 
   ServerGetVersionResult(this.version);
 
   factory ServerGetVersionResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String version;
@@ skipping 38 matching lines @@
   }
 }
 
 /**
  * server.setSubscriptions params
  *
  * {
  *   "subscriptions": List<ServerService>
  * }
  */
-class ServerSetSubscriptionsParams {
+class ServerSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   final List<ServerService> subscriptions;
 
   ServerSetSubscriptionsParams(this.subscriptions);
 
   factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<ServerService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new ServerSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params");
     }
   }
 
   factory ServerSetSubscriptionsParams.fromRequest(Request request) {
     return new ServerSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["subscriptions"] = subscriptions.map((ServerService value) => value.toJson());
+    result["subscriptions"] = subscriptions.map((ServerService value) => value.toJson()).toList();
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "server.setSubscriptions", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ServerSetSubscriptionsParams) {
       return _listEqual(subscriptions, other.subscriptions, (ServerService a, ServerService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * server.error params
  *
  * {
  *   "fatal": bool
  *   "message": String
  *   "stackTrace": String
  * }
  */
-class ServerErrorParams {
+class ServerErrorParams implements HasToJson {
   /**
    * True if the error is a fatal error, meaning that the server will shutdown
    * automatically after sending this notification.
    */
   final bool fatal;
 
   /**
    * The error message indicating what kind of error was encountered.
    */
   final String message;
@@ skipping 68 matching lines @@
   }
 }
 
 /**
  * server.status params
  *
  * {
  *   "analysis": optional AnalysisStatus
  * }
  */
-class ServerStatusParams {
+class ServerStatusParams implements HasToJson {
   /**
    * The current status of analysis, including whether analysis is being
    * performed and if so what is being analyzed.
    */
   final AnalysisStatus analysis;
 
   ServerStatusParams({this.analysis});
 
   factory ServerStatusParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
@@ skipping 39 matching lines @@
   }
 }
 
 /**
  * analysis.getErrors params
  *
  * {
  *   "file": FilePath
  * }
  */
-class AnalysisGetErrorsParams {
+class AnalysisGetErrorsParams implements HasToJson {
   /**
    * The file for which errors are being requested.
    */
   final String file;
 
   AnalysisGetErrorsParams(this.file);
 
   factory AnalysisGetErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String file;
@@ skipping 12 matching lines @@
     return new AnalysisGetErrorsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.getErrors", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetErrorsParams) {
       return file == other.file;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getErrors result
  *
  * {
  *   "errors": List<AnalysisError>
  * }
  */
-class AnalysisGetErrorsResult {
+class AnalysisGetErrorsResult implements HasToJson {
   /**
    * The errors associated with the file.
    */
   final List<AnalysisError> errors;
 
   AnalysisGetErrorsResult(this.errors);
 
   factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<AnalysisError> errors;
       if (json.containsKey("errors")) {
         errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "errors");
       }
       return new AnalysisGetErrorsResult(errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result");
     }
   }
 
   factory AnalysisGetErrorsResult.fromResponse(Response response) {
     return new AnalysisGetErrorsResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["errors"] = errors.map((AnalysisError value) => value.toJson());
+    result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetErrorsResult) {
       return _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
@@ skipping 10 matching lines @@
 }
 
 /**
  * analysis.getHover params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class AnalysisGetHoverParams {
+class AnalysisGetHoverParams implements HasToJson {
   /**
    * The file in which hover information is being requested.
    */
   final String file;
 
   /**
    * The offset for which hover information is being requested.
    */
   final int offset;
 
@@ skipping 24 matching lines @@
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.getHover", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetHoverParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getHover result
  *
  * {
  *   "hovers": List<HoverInformation>
  * }
  */
-class AnalysisGetHoverResult {
+class AnalysisGetHoverResult implements HasToJson {
   /**
    * The hover information associated with the location. The list will be empty
    * if no information could be determined for the location. The list can
    * contain multiple items if the file is being analyzed in multiple contexts
    * in conflicting ways (such as a part that is included in multiple
    * libraries).
    */
   final List<HoverInformation> hovers;
 
   AnalysisGetHoverResult(this.hovers);
@@ skipping 12 matching lines @@
     }
   }
 
   factory AnalysisGetHoverResult.fromResponse(Response response) {
     return new AnalysisGetHoverResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["hovers"] = hovers.map((HoverInformation value) => value.toJson());
+    result["hovers"] = hovers.map((HoverInformation value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisGetHoverResult) {
       return _listEqual(hovers, other.hovers, (HoverInformation a, HoverInformation b) => a == b);
@@ skipping 10 matching lines @@
 }
 
 /**
  * analysis.setAnalysisRoots params
  *
  * {
  *   "included": List<FilePath>
  *   "excluded": List<FilePath>
  * }
  */
-class AnalysisSetAnalysisRootsParams {
+class AnalysisSetAnalysisRootsParams implements HasToJson {
   /**
    * A list of the files and directories that should be analyzed.
    */
   final List<String> included;
 
   /**
    * A list of the files and directories within the included directories that
    * should not be analyzed.
    */
   final List<String> excluded;
@@ skipping 25 matching lines @@
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["included"] = included;
     result["excluded"] = excluded;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.setAnalysisRoots", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetAnalysisRootsParams) {
       return _listEqual(included, other.included, (String a, String b) => a == b) &&
           _listEqual(excluded, other.excluded, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, included.hashCode);
     hash = _JenkinsSmiHash.combine(hash, excluded.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-class AnalysisSetPriorityFilesParams {
+class AnalysisSetPriorityFilesParams implements HasToJson {
   /**
    * The files that are to be a priority for analysis.
    */
   final List<String> files;
 
   AnalysisSetPriorityFilesParams(this.files);
 
   factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<String> files;
@@ skipping 12 matching lines @@
     return new AnalysisSetPriorityFilesParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = files;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.setPriorityFiles", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetPriorityFilesParams) {
       return _listEqual(files, other.files, (String a, String b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, files.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setSubscriptions params
  *
  * {
  *   "subscriptions": Map<AnalysisService, List<FilePath>>
  * }
  */
-class AnalysisSetSubscriptionsParams {
+class AnalysisSetSubscriptionsParams implements HasToJson {
   /**
    * A table mapping services to a list of the files being subscribed to the
    * service.
    */
   final Map<AnalysisService, List<String>> subscriptions;
 
   AnalysisSetSubscriptionsParams(this.subscriptions);
 
   factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
@@ skipping 13 matching lines @@
     return new AnalysisSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["subscriptions"] = _mapMap(subscriptions, keyCallback: (AnalysisService value) => value.toJson());
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.setSubscriptions", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisSetSubscriptionsParams) {
       return _mapEqual(subscriptions, other.subscriptions, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b));
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.updateContent params
  *
  * {
  *   "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveContentOverlay>
  * }
  */
-class AnalysisUpdateContentParams {
+class AnalysisUpdateContentParams implements HasToJson {
   /**
    * A table mapping the files whose content has changed to a description of
    * the content change.
    */
   final Map<String, dynamic> files;
 
   AnalysisUpdateContentParams(this.files);
 
   factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
@@ skipping 13 matching lines @@
     return new AnalysisUpdateContentParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["files"] = _mapMap(files, valueCallback: (dynamic value) => value.toJson());
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.updateContent", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisUpdateContentParams) {
       return _mapEqual(files, other.files, (dynamic a, dynamic b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, files.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.updateOptions params
  *
  * {
  *   "options": AnalysisOptions
  * }
  */
-class AnalysisUpdateOptionsParams {
+class AnalysisUpdateOptionsParams implements HasToJson {
   /**
    * The options that are to be used to control analysis.
    */
   final AnalysisOptions options;
 
   AnalysisUpdateOptionsParams(this.options);
 
   factory AnalysisUpdateOptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       AnalysisOptions options;
@@ skipping 12 matching lines @@
     return new AnalysisUpdateOptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["options"] = options.toJson();
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "analysis.updateOptions", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisUpdateOptionsParams) {
       return options == other.options;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, options.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
  *   "errors": List<AnalysisError>
  * }
  */
-class AnalysisErrorsParams {
+class AnalysisErrorsParams implements HasToJson {
   /**
    * The file containing the errors.
    */
   final String file;
 
   /**
    * The errors contained in the file.
    */
   final List<AnalysisError> errors;
 
@@ skipping 20 matching lines @@
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
     return new AnalysisErrorsParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["errors"] = errors.map((AnalysisError value) => value.toJson());
+    result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisErrorsParams) {
       return file == other.file &&
@@ skipping 11 matching lines @@
   }
 }
 
 /**
  * analysis.flushResults params
  *
  * {
  *   "files": List<FilePath>
  * }
  */
-class AnalysisFlushResultsParams {
+class AnalysisFlushResultsParams implements HasToJson {
   /**
    * The files that are no longer being analyzed.
    */
   final List<String> files;
 
   AnalysisFlushResultsParams(this.files);
 
   factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<String> files;
@@ skipping 39 matching lines @@
 }
 
 /**
  * analysis.folding params
  *
  * {
  *   "file": FilePath
  *   "regions": List<FoldingRegion>
  * }
  */
-class AnalysisFoldingParams {
+class AnalysisFoldingParams implements HasToJson {
   /**
    * The file containing the folding regions.
    */
   final String file;
 
   /**
    * The folding regions contained in the file.
    */
   final List<FoldingRegion> regions;
 
@@ skipping 20 matching lines @@
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
     return new AnalysisFoldingParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((FoldingRegion value) => value.toJson());
+    result["regions"] = regions.map((FoldingRegion value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisFoldingParams) {
       return file == other.file &&
@@ skipping 12 matching lines @@
 }
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
  *   "regions": List<HighlightRegion>
  * }
  */
-class AnalysisHighlightsParams {
+class AnalysisHighlightsParams implements HasToJson {
   /**
    * The file containing the highlight regions.
    */
   final String file;
 
   /**
    * The highlight regions contained in the file. Each highlight region
    * represents a particular syntactic or semantic meaning associated with some
    * range. Note that the highlight regions that are returned can overlap other
    * highlight regions if there is more than one meaning associated with a
@@ skipping 24 matching lines @@
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
     return new AnalysisHighlightsParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((HighlightRegion value) => value.toJson());
+    result["regions"] = regions.map((HighlightRegion value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisHighlightsParams) {
       return file == other.file &&
@@ skipping 12 matching lines @@
 }
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
  *   "regions": List<NavigationRegion>
  * }
  */
-class AnalysisNavigationParams {
+class AnalysisNavigationParams implements HasToJson {
   /**
    * The file containing the navigation regions.
    */
   final String file;
 
   /**
    * The navigation regions contained in the file. Each navigation region
    * represents a list of targets associated with some range. The lists will
    * usually contain a single target, but can contain more in the case of a
    * part that is included in multiple libraries or in Dart code that is
@@ skipping 25 matching lines @@
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
     return new AnalysisNavigationParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["regions"] = regions.map((NavigationRegion value) => value.toJson());
+    result["regions"] = regions.map((NavigationRegion value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisNavigationParams) {
       return file == other.file &&
@@ skipping 12 matching lines @@
 }
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
  *   "occurrences": List<Occurrences>
  * }
  */
-class AnalysisOccurrencesParams {
+class AnalysisOccurrencesParams implements HasToJson {
   /**
    * The file in which the references occur.
    */
   final String file;
 
   /**
    * The occurrences of references to elements within the file.
    */
   final List<Occurrences> occurrences;
 
@@ skipping 20 matching lines @@
   }
 
   factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
     return new AnalysisOccurrencesParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["occurrences"] = occurrences.map((Occurrences value) => value.toJson());
+    result["occurrences"] = occurrences.map((Occurrences value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisOccurrencesParams) {
       return file == other.file &&
@@ skipping 12 matching lines @@
 }
 
 /**
  * analysis.outline params
  *
  * {
  *   "file": FilePath
  *   "outline": Outline
  * }
  */
-class AnalysisOutlineParams {
+class AnalysisOutlineParams implements HasToJson {
   /**
    * The file with which the outline is associated.
    */
   final String file;
 
   /**
    * The outline associated with the file.
    */
   final Outline outline;
 
@@ skipping 53 matching lines @@
 }
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
  *   "overrides": List<Override>
  * }
  */
-class AnalysisOverridesParams {
+class AnalysisOverridesParams implements HasToJson {
   /**
    * The file with which the overrides are associated.
    */
   final String file;
 
   /**
    * The overrides associated with the file.
    */
   final List<Override> overrides;
 
@@ skipping 20 matching lines @@
   }
 
   factory AnalysisOverridesParams.fromNotification(Notification notification) {
     return new AnalysisOverridesParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["overrides"] = overrides.map((Override value) => value.toJson());
+    result["overrides"] = overrides.map((Override value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisOverridesParams) {
       return file == other.file &&
@@ skipping 12 matching lines @@
 }
 
 /**
  * completion.getSuggestions params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class CompletionGetSuggestionsParams {
+class CompletionGetSuggestionsParams implements HasToJson {
   /**
    * The file containing the point at which suggestions are to be made.
    */
   final String file;
 
   /**
    * The offset within the file at which suggestions are to be made.
    */
   final int offset;
 
@@ skipping 24 matching lines @@
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "completion.getSuggestions", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is CompletionGetSuggestionsParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * completion.getSuggestions result
  *
  * {
  *   "id": CompletionId
  * }
  */
-class CompletionGetSuggestionsResult {
+class CompletionGetSuggestionsResult implements HasToJson {
   /**
    * The identifier used to associate results with this completion request.
    */
   final String id;
 
   CompletionGetSuggestionsResult(this.id);
 
   factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 42 matching lines @@
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
  *   "results": List<CompletionSuggestion>
  *   "last": bool
  * }
  */
-class CompletionResultsParams {
+class CompletionResultsParams implements HasToJson {
   /**
    * The id associated with the completion.
    */
   final String id;
 
   /**
    * The offset of the start of the text to be replaced. This will be different
    * than the offset used to request the completion suggestions if there was a
    * portion of an identifier before the original offset. In particular, the
    * replacementOffset will be the offset of the beginning of said identifier.
@@ skipping 65 matching lines @@
   factory CompletionResultsParams.fromNotification(Notification notification) {
     return new CompletionResultsParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     result["replacementOffset"] = replacementOffset;
     result["replacementLength"] = replacementLength;
-    result["results"] = results.map((CompletionSuggestion value) => value.toJson());
+    result["results"] = results.map((CompletionSuggestion value) => value.toJson()).toList();
     result["last"] = last;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is CompletionResultsParams) {
@@ skipping 20 matching lines @@
 
 /**
  * search.findElementReferences params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "includePotential": bool
  * }
  */
-class SearchFindElementReferencesParams {
+class SearchFindElementReferencesParams implements HasToJson {
   /**
    * The file containing the declaration of or reference to the element used to
    * define the search.
    */
   final String file;
 
   /**
    * The offset within the file of the declaration of or reference to the
    * element.
    */
@@ skipping 38 matching lines @@
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["includePotential"] = includePotential;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "search.findElementReferences", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchFindElementReferencesParams) {
       return file == other.file &&
           offset == other.offset &&
           includePotential == other.includePotential;
     }
@@ skipping 11 matching lines @@
 }
 
 /**
  * search.findElementReferences result
  *
  * {
  *   "id": SearchId
  *   "element": Element
  * }
  */
-class SearchFindElementReferencesResult {
+class SearchFindElementReferencesResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   /**
    * The element referenced or defined at the given offset and whose references
    * will be returned in the search results.
    */
   final Element element;
@@ skipping 53 matching lines @@
   }
 }
 
 /**
  * search.findMemberDeclarations params
  *
  * {
  *   "name": String
  * }
  */
-class SearchFindMemberDeclarationsParams {
+class SearchFindMemberDeclarationsParams implements HasToJson {
   /**
    * The name of the declarations to be found.
    */
   final String name;
 
   SearchFindMemberDeclarationsParams(this.name);
 
   factory SearchFindMemberDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String name;
@@ skipping 12 matching lines @@
     return new SearchFindMemberDeclarationsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "search.findMemberDeclarations", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchFindMemberDeclarationsParams) {
       return name == other.name;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, name.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindMemberDeclarationsResult {
+class SearchFindMemberDeclarationsResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindMemberDeclarationsResult(this.id);
 
   factory SearchFindMemberDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 38 matching lines @@
   }
 }
 
 /**
  * search.findMemberReferences params
  *
  * {
  *   "name": String
  * }
  */
-class SearchFindMemberReferencesParams {
+class SearchFindMemberReferencesParams implements HasToJson {
   /**
    * The name of the references to be found.
    */
   final String name;
 
   SearchFindMemberReferencesParams(this.name);
 
   factory SearchFindMemberReferencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String name;
@@ skipping 12 matching lines @@
     return new SearchFindMemberReferencesParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "search.findMemberReferences", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchFindMemberReferencesParams) {
       return name == other.name;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, name.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findMemberReferences result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindMemberReferencesResult {
+class SearchFindMemberReferencesResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindMemberReferencesResult(this.id);
 
   factory SearchFindMemberReferencesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 38 matching lines @@
   }
 }
 
 /**
  * search.findTopLevelDeclarations params
  *
  * {
  *   "pattern": String
  * }
  */
-class SearchFindTopLevelDeclarationsParams {
+class SearchFindTopLevelDeclarationsParams implements HasToJson {
   /**
    * The regular expression used to match the names of the declarations to be
    * found.
    */
   final String pattern;
 
   SearchFindTopLevelDeclarationsParams(this.pattern);
 
   factory SearchFindTopLevelDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
@@ skipping 13 matching lines @@
     return new SearchFindTopLevelDeclarationsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["pattern"] = pattern;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "search.findTopLevelDeclarations", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchFindTopLevelDeclarationsParams) {
       return pattern == other.pattern;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, pattern.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.findTopLevelDeclarations result
  *
  * {
  *   "id": SearchId
  * }
  */
-class SearchFindTopLevelDeclarationsResult {
+class SearchFindTopLevelDeclarationsResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindTopLevelDeclarationsResult(this.id);
 
   factory SearchFindTopLevelDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 39 matching lines @@
 }
 
 /**
  * search.getTypeHierarchy params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class SearchGetTypeHierarchyParams {
+class SearchGetTypeHierarchyParams implements HasToJson {
   /**
    * The file containing the declaration or reference to the type for which a
    * hierarchy is being requested.
    */
   final String file;
 
   /**
    * The offset of the name of the type within the file.
    */
   final int offset;
@@ skipping 25 matching lines @@
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "search.getTypeHierarchy", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchGetTypeHierarchyParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.getTypeHierarchy result
  *
  * {
  *   "hierarchyItems": optional List<TypeHierarchyItem>
  * }
  */
-class SearchGetTypeHierarchyResult {
+class SearchGetTypeHierarchyResult implements HasToJson {
   /**
    * A list of the types in the requested hierarchy. The first element of the
    * list is the item representing the type for which the hierarchy was
    * requested. The index of other elements of the list is unspecified, but
    * correspond to the integers used to reference supertype and subtype items
    * within the items.
    *
    * This field will be absent if the code at the given file and offset does
    * not represent a type, or if the file has not been sufficiently analyzed to
    * allow a type hierarchy to be produced.
@@ skipping 15 matching lines @@
   }
 
   factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
     return new SearchGetTypeHierarchyResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (hierarchyItems != null) {
-      result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson());
+      result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchGetTypeHierarchyResult) {
@@ skipping 12 matching lines @@
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
  *   "results": List<SearchResult>
  *   "last": bool
  * }
  */
-class SearchResultsParams {
+class SearchResultsParams implements HasToJson {
   /**
    * The id associated with the search.
    */
   final String id;
 
   /**
    * The search results being reported.
    */
   final List<SearchResult> results;
 
@@ skipping 32 matching lines @@
   }
 
   factory SearchResultsParams.fromNotification(Notification notification) {
     return new SearchResultsParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
-    result["results"] = results.map((SearchResult value) => value.toJson());
+    result["results"] = results.map((SearchResult value) => value.toJson()).toList();
     result["last"] = last;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchResultsParams) {
@@ skipping 16 matching lines @@
 
 /**
  * edit.getAssists params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-class EditGetAssistsParams {
+class EditGetAssistsParams implements HasToJson {
   /**
    * The file containing the code for which assists are being requested.
    */
   final String file;
 
   /**
    * The offset of the code for which assists are being requested.
    */
   final int offset;
 
@@ skipping 36 matching lines @@
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "edit.getAssists", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAssistsParams) {
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
@@ skipping 10 matching lines @@
   }
 }
 
 /**
  * edit.getAssists result
  *
  * {
  *   "assists": List<SourceChange>
  * }
  */
-class EditGetAssistsResult {
+class EditGetAssistsResult implements HasToJson {
   /**
    * The assists that are available at the given location.
    */
   final List<SourceChange> assists;
 
   EditGetAssistsResult(this.assists);
 
   factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<SourceChange> assists;
       if (json.containsKey("assists")) {
         assists = jsonDecoder._decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "assists");
       }
       return new EditGetAssistsResult(assists);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result");
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
     return new EditGetAssistsResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["assists"] = assists.map((SourceChange value) => value.toJson());
+    result["assists"] = assists.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAssistsResult) {
       return _listEqual(assists, other.assists, (SourceChange a, SourceChange b) => a == b);
@@ skipping 11 matching lines @@
 
 /**
  * edit.getAvailableRefactorings params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  * }
  */
-class EditGetAvailableRefactoringsParams {
+class EditGetAvailableRefactoringsParams implements HasToJson {
   /**
    * The file containing the code on which the refactoring would be based.
    */
   final String file;
 
   /**
    * The offset of the code on which the refactoring would be based.
    */
   final int offset;
 
@@ skipping 36 matching lines @@
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "edit.getAvailableRefactorings", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAvailableRefactoringsParams) {
       return file == other.file &&
           offset == other.offset &&
           length == other.length;
     }
@@ skipping 10 matching lines @@
   }
 }
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
  *   "kinds": List<RefactoringKind>
  * }
  */
-class EditGetAvailableRefactoringsResult {
+class EditGetAvailableRefactoringsResult implements HasToJson {
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   final List<RefactoringKind> kinds;
 
   EditGetAvailableRefactoringsResult(this.kinds);
 
   factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<RefactoringKind> kinds;
       if (json.containsKey("kinds")) {
         kinds = jsonDecoder._decodeList(jsonPath + ".kinds", json["kinds"], (String jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kinds");
       }
       return new EditGetAvailableRefactoringsResult(kinds);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result");
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
     return new EditGetAvailableRefactoringsResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["kinds"] = kinds.map((RefactoringKind value) => value.toJson());
+    result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetAvailableRefactoringsResult) {
       return _listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
@@ skipping 10 matching lines @@
 }
 
 /**
  * edit.getFixes params
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class EditGetFixesParams {
+class EditGetFixesParams implements HasToJson {
   /**
    * The file containing the errors for which fixes are being requested.
    */
   final String file;
 
   /**
    * The offset used to select the errors for which fixes will be returned.
    */
   final int offset;
 
@@ skipping 24 matching lines @@
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "edit.getFixes", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetFixesParams) {
       return file == other.file &&
           offset == other.offset;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getFixes result
  *
  * {
  *   "fixes": List<ErrorFixes>
  * }
  */
-class EditGetFixesResult {
+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.
    */
   final List<ErrorFixes> fixes;
 
@@ skipping 13 matching lines @@
     }
   }
 
   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());
+    result["fixes"] = fixes.map((ErrorFixes value) => value.toJson()).toList();
     return result;
   }
 
   @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);
@@ skipping 14 matching lines @@
  *
  * {
  *   "kindId": RefactoringKind
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "validateOnly": bool
  *   "options": optional object
  * }
  */
-class EditGetRefactoringParams {
+class EditGetRefactoringParams implements HasToJson {
   /**
    * The identifier of the kind of refactoring to be performed.
    */
   final RefactoringKind kindId;
 
   /**
    * The file containing the code involved in the refactoring.
    */
   final String file;
 
@@ skipping 77 matching lines @@
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     result["validateOnly"] = validateOnly;
     if (options != null) {
       result["options"] = options;
     }
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "edit.getRefactoring", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is EditGetRefactoringParams) {
       return kindId == other.kindId &&
           file == other.file &&
           offset == other.offset &&
           length == other.length &&
@@ skipping 19 matching lines @@
 /**
  * edit.getRefactoring result
  *
  * {
  *   "status": List<RefactoringProblem>
  *   "feedback": optional object
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
  */
-class EditGetRefactoringResult {
+class EditGetRefactoringResult implements HasToJson {
   /**
    * The status of the refactoring. The array will be empty if there are no
    * known problems.
    */
   final List<RefactoringProblem> status;
 
   /**
    * Data used to provide feedback to the user. The structure of the data is
    * dependent on the kind of refactoring being created. The data that is
    * returned is documented in the section titled Refactorings, labeled as
@@ skipping 47 matching lines @@
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
         new ResponseDecoder(), "result", response.result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["status"] = status.map((RefactoringProblem value) => value.toJson());
+    result["status"] = status.map((RefactoringProblem value) => value.toJson()).toList();
     if (feedback != null) {
       result["feedback"] = feedback;
     }
     if (change != null) {
       result["change"] = change.toJson();
     }
     if (potentialEdits != null) {
       result["potentialEdits"] = potentialEdits;
     }
     return result;
@@ skipping 24 matching lines @@
   }
 }
 
 /**
  * debug.createContext params
  *
  * {
  *   "contextRoot": FilePath
  * }
  */
-class DebugCreateContextParams {
+class DebugCreateContextParams implements HasToJson {
   /**
    * The path of the Dart or HTML file that will be launched.
    */
   final String contextRoot;
 
   DebugCreateContextParams(this.contextRoot);
 
   factory DebugCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String contextRoot;
@@ skipping 12 matching lines @@
     return new DebugCreateContextParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["contextRoot"] = contextRoot;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "debug.createContext", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is DebugCreateContextParams) {
       return contextRoot == other.contextRoot;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, contextRoot.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * debug.createContext result
  *
  * {
  *   "id": DebugContextId
  * }
  */
-class DebugCreateContextResult {
+class DebugCreateContextResult implements HasToJson {
   /**
    * The identifier used to refer to the debugging context that was created.
    */
   final String id;
 
   DebugCreateContextResult(this.id);
 
   factory DebugCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 38 matching lines @@
   }
 }
 
 /**
  * debug.deleteContext params
  *
  * {
  *   "id": DebugContextId
  * }
  */
-class DebugDeleteContextParams {
+class DebugDeleteContextParams implements HasToJson {
   /**
    * The identifier of the debugging context that is to be deleted.
    */
   final String id;
 
   DebugDeleteContextParams(this.id);
 
   factory DebugDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String id;
@@ skipping 12 matching lines @@
     return new DebugDeleteContextParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["id"] = id;
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "debug.deleteContext", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is DebugDeleteContextParams) {
       return id == other.id;
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * debug.mapUri params
  *
  * {
  *   "id": DebugContextId
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriParams {
+class DebugMapUriParams implements HasToJson {
   /**
    * The identifier of the debugging context in which the URI is to be mapped.
    */
   final String id;
 
   /**
    * The path of the file to be mapped into a URI.
    */
   final String file;
 
@@ skipping 36 matching lines @@
     result["id"] = id;
     if (file != null) {
       result["file"] = file;
     }
     if (uri != null) {
       result["uri"] = uri;
     }
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "debug.mapUri", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is DebugMapUriParams) {
       return id == other.id &&
           file == other.file &&
           uri == other.uri;
     }
@@ skipping 11 matching lines @@
 }
 
 /**
  * debug.mapUri result
  *
  * {
  *   "file": optional FilePath
  *   "uri": optional String
  * }
  */
-class DebugMapUriResult {
+class DebugMapUriResult implements HasToJson {
   /**
    * The file to which the URI was mapped. This field is omitted if the uri
    * field was not given in the request.
    */
   final String file;
 
   /**
    * The URI to which the file path was mapped. This field is omitted if the
    * file field was not given in the request.
    */
@@ skipping 54 matching lines @@
   }
 }
 
 /**
  * debug.setSubscriptions params
  *
  * {
  *   "subscriptions": List<DebugService>
  * }
  */
-class DebugSetSubscriptionsParams {
+class DebugSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   final List<DebugService> subscriptions;
 
   DebugSetSubscriptionsParams(this.subscriptions);
 
   factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       List<DebugService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new DebugService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new DebugSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.setSubscriptions params");
     }
   }
 
   factory DebugSetSubscriptionsParams.fromRequest(Request request) {
     return new DebugSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["subscriptions"] = subscriptions.map((DebugService value) => value.toJson());
+    result["subscriptions"] = subscriptions.map((DebugService value) => value.toJson()).toList();
     return result;
   }
 
+  Request toRequest(String id) {
+    return new Request(id, "debug.setSubscriptions", toJson());
+  }
+
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is DebugSetSubscriptionsParams) {
       return _listEqual(subscriptions, other.subscriptions, (DebugService a, DebugService b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * debug.launchData params
  *
  * {
  *   "executables": List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
-class DebugLaunchDataParams {
+class DebugLaunchDataParams implements HasToJson {
   /**
    * A list of the files that are executable in the given context. This list
    * replaces any previous list provided for the given context.
    */
   final List<ExecutableFile> executables;
 
   /**
    * A mapping from the paths of Dart files that are referenced by HTML files
    * to a list of the HTML files that reference the Dart files.
    */
@@ skipping 33 matching lines @@
     }
   }
 
   factory DebugLaunchDataParams.fromNotification(Notification notification) {
     return new DebugLaunchDataParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["executables"] = executables.map((ExecutableFile value) => value.toJson());
+    result["executables"] = executables.map((ExecutableFile value) => value.toJson()).toList();
     result["dartToHtml"] = dartToHtml;
     result["htmlToDart"] = htmlToDart;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
@@ skipping 16 matching lines @@
 }
 
 /**
  * AddContentOverlay
  *
  * {
  *   "type": "add"
  *   "content": String
  * }
  */
-class AddContentOverlay {
+class AddContentOverlay implements HasToJson {
   /**
    * The new content of the file.
    */
   final String content;
 
   AddContentOverlay(this.content);
 
   factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       if (json["type"] != "add") {
@@ skipping 42 matching lines @@
  * AnalysisError
  *
  * {
  *   "severity": ErrorSeverity
  *   "type": ErrorType
  *   "location": Location
  *   "message": String
  *   "correction": optional String
  * }
  */
-class AnalysisError {
+class AnalysisError implements HasToJson {
   /**
    * The severity of the error.
    */
   final ErrorSeverity severity;
 
   /**
    * The type of the error.
    */
   final ErrorType type;
 
@@ skipping 96 matching lines @@
  * AnalysisOptions
  *
  * {
  *   "enableAsync": optional bool
  *   "enableDeferredLoading": optional bool
  *   "enableEnums": optional bool
  *   "generateDart2jsHints": optional bool
  *   "generateHints": optional bool
  * }
  */
-class AnalysisOptions {
+class AnalysisOptions implements HasToJson {
   /**
    * True if the client wants to enable support for the proposed async feature.
    */
   final bool enableAsync;
 
   /**
    * True if the client wants to enable support for the proposed deferred
    * loading feature.
    */
   final bool enableDeferredLoading;
@@ skipping 157 matching lines @@
 }
 
 /**
  * AnalysisStatus
  *
  * {
  *   "analyzing": bool
  *   "analysisTarget": optional String
  * }
  */
-class AnalysisStatus {
+class AnalysisStatus implements HasToJson {
   /**
    * True if analysis is currently being performed.
    */
   final bool analyzing;
 
   /**
    * The name of the current target of analysis. This field is omitted if
    * analyzing is false.
    */
   final String analysisTarget;
@@ skipping 49 matching lines @@
 }
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
  *   "edits": List<SourceEdit>
  * }
  */
-class ChangeContentOverlay {
+class ChangeContentOverlay implements HasToJson {
   /**
    * The edits to be applied to the file.
    */
   final List<SourceEdit> edits;
 
   ChangeContentOverlay(this.edits);
 
   factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       if (json["type"] != "change") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "change");
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
         edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       return new ChangeContentOverlay(edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "change";
-    result["edits"] = edits.map((SourceEdit value) => value.toJson());
+    result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ChangeContentOverlay) {
       return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
@@ skipping 75 matching lines @@
  *   "declaringType": optional String
  *   "returnType": optional String
  *   "parameterNames": optional List<String>
  *   "parameterTypes": optional List<String>
  *   "requiredParameterCount": optional int
  *   "positionalParameterCount": optional int
  *   "parameterName": optional String
  *   "parameterType": optional String
  * }
  */
-class CompletionSuggestion {
+class CompletionSuggestion implements HasToJson {
   /**
    * The kind of element being suggested.
    */
   final CompletionSuggestionKind kind;
 
   /**
    * The relevance of this completion suggestion.
    */
   final CompletionRelevance relevance;
 
@@ skipping 454 matching lines @@
  *
  * {
  *   "kind": ElementKind
  *   "name": String
  *   "location": optional Location
  *   "flags": int
  *   "parameters": optional String
  *   "returnType": optional String
  * }
  */
-class Element {
+class Element implements HasToJson {
   /**
    * The kind of the element.
    */
   final ElementKind kind;
 
   /**
    * The name of the element. This is typically used as the label in the
    * outline.
    */
   final String name;
@@ skipping 242 matching lines @@
 
 /**
  * Error
  *
  * {
  *   "code": String
  *   "message": String
  *   "data": optional object
  * }
  */
-class Error {
+class Error implements HasToJson {
   /**
    * A code that uniquely identifies the error that occurred.
    */
   final String code;
 
   /**
    * A short description of the error.
    */
   final String message;
 
@@ skipping 63 matching lines @@
 }
 
 /**
  * ErrorFixes
  *
  * {
  *   "error": AnalysisError
  *   "fixes": List<SourceChange>
  * }
  */
-class ErrorFixes {
+class ErrorFixes implements HasToJson {
   /**
    * The error with which the fixes are associated.
    */
   final AnalysisError error;
 
   /**
    * The fixes associated with the error.
    */
   final List<SourceChange> fixes;
 
@@ skipping 15 matching lines @@
       }
       return new ErrorFixes(error, 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());
+    result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ErrorFixes) {
       return error == other.error &&
@@ skipping 125 matching lines @@
 }
 
 /**
  * ExecutableFile
  *
  * {
  *   "file": FilePath
  *   "offset": ExecutableKind
  * }
  */
-class ExecutableFile {
+class ExecutableFile implements HasToJson {
   /**
    * The path of the executable file.
    */
   final String file;
 
   /**
    * The offset of the region to be highlighted.
    */
   final ExecutableKind offset;
 
@@ skipping 157 matching lines @@
 
 /**
  * FoldingRegion
  *
  * {
  *   "kind": FoldingKind
  *   "offset": int
  *   "length": int
  * }
  */
-class FoldingRegion {
+class FoldingRegion implements HasToJson {
   /**
    * The kind of the region.
    */
   final FoldingKind kind;
 
   /**
    * The offset of the region to be folded.
    */
   final int offset;
 
@@ skipping 63 matching lines @@
 
 /**
  * HighlightRegion
  *
  * {
  *   "type": HighlightRegionType
  *   "offset": int
  *   "length": int
  * }
  */
-class HighlightRegion {
+class HighlightRegion implements HasToJson {
   /**
    * The type of highlight associated with the region.
    */
   final HighlightRegionType type;
 
   /**
    * The offset of the region to be highlighted.
    */
   final int offset;
 
@@ skipping 279 matching lines @@
  *   "containingLibraryPath": optional String
  *   "containingLibraryName": optional String
  *   "dartdoc": optional String
  *   "elementDescription": optional String
  *   "elementKind": optional String
  *   "parameter": optional String
  *   "propagatedType": optional String
  *   "staticType": optional String
  * }
  */
-class HoverInformation {
+class HoverInformation implements HasToJson {
   /**
    * The offset of the range of characters that encompases the cursor position
    * and has the same hover information as the cursor position.
    */
   final int offset;
 
   /**
    * The length of the range of characters that encompases the cursor position
    * and has the same hover information as the cursor position.
    */
@@ skipping 177 matching lines @@
 
 /**
  * LinkedEditGroup
  *
  * {
  *   "positions": List<Position>
  *   "length": int
  *   "suggestions": List<LinkedEditSuggestion>
  * }
  */
-class LinkedEditGroup {
+class LinkedEditGroup implements HasToJson {
   /**
    * The positions of the regions that should be edited simultaneously.
    */
   final List<Position> positions;
 
   /**
    * The length of the regions that should be edited simultaneously.
    */
   final int length;
 
@@ skipping 26 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "suggestions");
       }
       return new LinkedEditGroup(positions, length, suggestions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["positions"] = positions.map((Position value) => value.toJson());
+    result["positions"] = positions.map((Position value) => value.toJson()).toList();
     result["length"] = length;
-    result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => value.toJson());
+    result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is LinkedEditGroup) {
       return _listEqual(positions, other.positions, (Position a, Position b) => a == b) &&
@@ skipping 14 matching lines @@
 }
 
 /**
  * LinkedEditSuggestion
  *
  * {
  *   "value": String
  *   "kind": LinkedEditSuggestionKind
  * }
  */
-class LinkedEditSuggestion {
+class LinkedEditSuggestion implements HasToJson {
   /**
    * The value that could be used to replace all of the linked edit regions.
    */
   final String value;
 
   /**
    * The kind of value being proposed.
    */
   final LinkedEditSuggestionKind kind;
 
@@ skipping 105 matching lines @@
  * Location
  *
  * {
  *   "file": FilePath
  *   "offset": int
  *   "length": int
  *   "startLine": int
  *   "startColumn": int
  * }
  */
-class Location {
+class Location implements HasToJson {
   /**
    * The file containing the range.
    */
   final String file;
 
   /**
    * The offset of the range.
    */
   final int offset;
 
@@ skipping 93 matching lines @@
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
  *   "targets": List<Element>
  * }
  */
-class NavigationRegion {
+class NavigationRegion implements HasToJson {
   /**
    * The offset of the region from which the user can navigate.
    */
   final int offset;
 
   /**
    * The length of the region from which the user can navigate.
    */
   final int length;
 
@@ skipping 28 matching lines @@
       return new NavigationRegion(offset, length, targets);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "NavigationRegion");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
-    result["targets"] = targets.map((Element value) => value.toJson());
+    result["targets"] = targets.map((Element value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is NavigationRegion) {
       return offset == other.offset &&
@@ skipping 15 matching lines @@
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
  *   "offsets": List<int>
  *   "length": int
  * }
  */
-class Occurrences {
+class Occurrences implements HasToJson {
   /**
    * The element that was referenced.
    */
   final Element element;
 
   /**
    * The offsets of the name of the referenced element within the file.
    */
   final List<int> offsets;
 
@@ skipping 64 matching lines @@
 /**
  * Outline
  *
  * {
  *   "element": Element
  *   "offset": int
  *   "length": int
  *   "children": optional List<Outline>
  * }
  */
-class Outline {
+class Outline implements HasToJson {
   /**
    * A description of the element represented by this node.
    */
   final Element element;
 
   /**
    * The offset of the first character of the element. This is different than
    * the offset in the Element, which if the offset of the name of the element.
    * It can be used, for example, to map locations in the file back to an
    * outline.
@@ skipping 42 matching lines @@
       throw jsonDecoder.mismatch(jsonPath, "Outline");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offset"] = offset;
     result["length"] = length;
     if (children != null) {
-      result["children"] = children.map((Outline value) => value.toJson());
+      result["children"] = children.map((Outline value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Outline) {
@@ skipping 19 matching lines @@
 /**
  * Override
  *
  * {
  *   "offset": int
  *   "length": int
  *   "superclassMember": optional OverriddenMember
  *   "interfaceMembers": optional List<OverriddenMember>
  * }
  */
-class Override {
+class Override implements HasToJson {
   /**
    * The offset of the name of the overriding member.
    */
   final int offset;
 
   /**
    * The length of the name of the overriding member.
    */
   final int length;
 
@@ skipping 42 matching lines @@
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     if (superclassMember != null) {
       result["superclassMember"] = superclassMember.toJson();
     }
     if (interfaceMembers != null) {
-      result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value) => value.toJson());
+      result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Override) {
@@ skipping 17 matching lines @@
 }
 
 /**
  * OverriddenMember
  *
  * {
  *   "element": Element
  *   "className": String
  * }
  */
-class OverriddenMember {
+class OverriddenMember implements HasToJson {
   /**
    * The element that is being overridden.
    */
   final Element element;
 
   /**
    * The name of the class in which the member is defined.
    */
   final String className;
 
@@ skipping 48 matching lines @@
 }
 
 /**
  * Position
  *
  * {
  *   "file": FilePath
  *   "offset": int
  * }
  */
-class Position {
+class Position implements HasToJson {
   /**
    * The file containing the position.
    */
   final String file;
 
   /**
    * The offset of the position.
    */
   final int offset;
 
@@ skipping 120 matching lines @@
  * RefactoringMethodParameter
  *
  * {
  *   "id": optional String
  *   "kind": RefactoringMethodParameterKind
  *   "type": String
  *   "name": String
  *   "parameters": optional String
  * }
  */
-class RefactoringMethodParameter {
+class RefactoringMethodParameter implements HasToJson {
   /**
    * The unique identifier of the parameter. Clients may omit this field for
    * the parameters they want to add.
    */
   final String id;
 
   /**
    * The kind of the parameter.
    */
   final RefactoringMethodParameterKind kind;
@@ skipping 144 matching lines @@
 
 /**
  * RefactoringProblem
  *
  * {
  *   "severity": RefactoringProblemSeverity
  *   "message": String
  *   "location": Location
  * }
  */
-class RefactoringProblem {
+class RefactoringProblem implements HasToJson {
   /**
    * The severity of the problem being represented.
    */
   final RefactoringProblemSeverity severity;
 
   /**
    * A human-readable description of the problem being represented.
    */
   final String message;
 
@@ skipping 115 matching lines @@
   String toJson() => name;
 }
 
 /**
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
  */
-class RemoveContentOverlay {
+class RemoveContentOverlay implements HasToJson {
   RemoveContentOverlay();
 
   factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       if (json["type"] != "remove") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "remove");
       }
       return new RemoveContentOverlay();
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay");
@@ skipping 28 matching lines @@
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
  *   "path": List<Element>
  * }
  */
-class SearchResult {
+class SearchResult implements HasToJson {
   /**
    * The location of the code that matched the search criteria.
    */
   final Location location;
 
   /**
    * The kind of element that was found or the kind of reference that was
    * found.
    */
   final SearchResultKind kind;
@@ skipping 44 matching lines @@
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SearchResult");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["location"] = location.toJson();
     result["kind"] = kind.toJson();
     result["isPotential"] = isPotential;
-    result["path"] = path.map((Element value) => value.toJson());
+    result["path"] = path.map((Element value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SearchResult) {
       return location == other.location &&
@@ skipping 140 matching lines @@
 /**
  * SourceChange
  *
  * {
  *   "message": String
  *   "edits": List<SourceFileEdit>
  *   "linkedEditGroups": List<LinkedEditGroup>
  *   "selection": optional Position
  * }
  */
-class SourceChange {
+class SourceChange implements HasToJson {
   /**
    * A human-readable description of the change to be applied.
    */
   final String message;
 
   /**
    * A list of the edits used to effect the change, grouped by file.
    */
   final List<SourceFileEdit> edits;
 
@@ skipping 36 matching lines @@
       }
       return new SourceChange(message, edits, linkedEditGroups, selection: selection);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceChange");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["message"] = message;
-    result["edits"] = edits.map((SourceFileEdit value) => value.toJson());
-    result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson());
+    result["edits"] = edits.map((SourceFileEdit value) => value.toJson()).toList();
+    result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson()).toList();
     if (selection != null) {
       result["selection"] = selection.toJson();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
@@ skipping 21 matching lines @@
 /**
  * SourceEdit
  *
  * {
  *   "offset": int
  *   "length": int
  *   "replacement": String
  *   "id": optional String
  * }
  */
-class SourceEdit {
+class SourceEdit implements HasToJson {
   /**
    * The offset of the region to be modified.
    */
   final int offset;
 
   /**
    * The length of the region to be modified.
    */
   final int length;
 
@@ skipping 83 matching lines @@
 }
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
  *   "edits": List<SourceEdit>
  * }
  */
-class SourceFileEdit {
+class SourceFileEdit implements HasToJson {
   /**
    * The file containing the code to be modified.
    */
   final String file;
 
   /**
    * A list of the edits used to effect the change.
    */
   final List<SourceEdit> edits;
 
@@ skipping 15 matching lines @@
       }
       return new SourceFileEdit(file, edits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
-    result["edits"] = edits.map((SourceEdit value) => value.toJson());
+    result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is SourceFileEdit) {
       return file == other.file &&
@@ skipping 17 matching lines @@
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
  *   "interfaces": List<int>
  *   "mixins": List<int>
  *   "subclasses": List<int>
  * }
  */
-class TypeHierarchyItem {
+class TypeHierarchyItem implements HasToJson {
   /**
    * The class element represented by this item.
    */
   final Element classElement;
 
   /**
    * The name to be displayed for the class. This field will be omitted if the
    * display name is the same as the name of the element. The display name is
    * different if there is additional type information to be displayed, such as
    * type arguments.
@@ skipping 130 matching lines @@
 
 /**
  * extractLocalVariable feedback
  *
  * {
  *   "names": List<String>
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractLocalVariableFeedback {
+class ExtractLocalVariableFeedback implements HasToJson {
   /**
    * The proposed names for the local variable.
    */
   final List<String> names;
 
   /**
    * The offsets of the expressions that would be replaced by a reference to
    * the variable.
    */
   final List<int> offsets;
@@ skipping 71 matching lines @@
 }
 
 /**
  * extractLocalVariable options
  *
  * {
  *   "name": String
  *   "extractAll": bool
  * }
  */
-class ExtractLocalVariableOptions {
+class ExtractLocalVariableOptions implements HasToJson {
   /**
    * The name that the local variable should be given.
    */
   final String name;
 
   /**
    * True if all occurrences of the expression within the scope in which the
    * variable will be defined should be replaced by a reference to the local
    * variable. The expression used to initiate the refactoring will always be
    * replaced.
@@ skipping 63 matching lines @@
  *   "length": int
  *   "returnType": String
  *   "names": List<String>
  *   "canCreateGetter": bool
  *   "parameters": List<RefactoringMethodParameter>
  *   "occurrences": int
  *   "offsets": List<int>
  *   "lengths": List<int>
  * }
  */
-class ExtractMethodFeedback {
+class ExtractMethodFeedback implements HasToJson {
   /**
    * The offset to the beginning of the expression or statements that will be
    * extracted.
    */
   final int offset;
 
   /**
    * The length of the expression or statements that will be extracted.
    */
   final int length;
@@ skipping 107 matching lines @@
         new ResponseDecoder(), "feedback", refactoringResult.feedback);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["returnType"] = returnType;
     result["names"] = names;
     result["canCreateGetter"] = canCreateGetter;
-    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson());
+    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
     result["occurrences"] = occurrences;
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
@@ skipping 32 matching lines @@
  * extractMethod options
  *
  * {
  *   "returnType": String
  *   "createGetter": bool
  *   "name": String
  *   "parameters": List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
  */
-class ExtractMethodOptions {
+class ExtractMethodOptions implements HasToJson {
   /**
    * The return type that should be defined for the method.
    */
   final String returnType;
 
   /**
    * True if a getter should be created rather than a method. It is an error if
    * this field is true and the list of parameters is non-empty.
    */
   final bool createGetter;
@@ skipping 67 matching lines @@
   factory ExtractMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
     return new ExtractMethodOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["returnType"] = returnType;
     result["createGetter"] = createGetter;
     result["name"] = name;
-    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson());
+    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
     result["extractAll"] = extractAll;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractMethodOptions) {
@@ skipping 19 matching lines @@
 }
 
 /**
  * inlineMethod options
  *
  * {
  *   "deleteSource": bool
  *   "inlineAll": bool
  * }
  */
-class InlineMethodOptions {
+class InlineMethodOptions implements HasToJson {
   /**
    * True if the method being inlined should be removed. It is an error if this
    * field is true and inlineAll is false.
    */
   final bool deleteSource;
 
   /**
    * True if all invocations of the method should be inlined, or false if only
    * the invocation site used to create this refactoring should be inlined.
    */
@@ skipping 55 matching lines @@
 }
 
 /**
  * rename feedback
  *
  * {
  *   "offset": int
  *   "length": int
  * }
  */
-class RenameFeedback {
+class RenameFeedback implements HasToJson {
   /**
    * The offset to the beginning of the name selected to be renamed.
    */
   final int offset;
 
   /**
    * The length of the name selected to be renamed.
    */
   final int length;
 
@@ skipping 52 matching lines @@
   }
 }
 
 /**
  * rename options
  *
  * {
  *   "newName": String
  * }
  */
-class RenameOptions {
+class RenameOptions implements HasToJson {
   /**
    * The name that the element should have after the refactoring.
    */
   final String newName;
 
   RenameOptions(this.newName);
 
   factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is Map) {
       String newName;
@@ skipping 30 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }