Change analysis server protocol to omit empty lists when optional.

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;
 
@@ skipping 60 matching lines @@
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, version.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * server.setSubscriptions params
  *
  * {
- *   "subscriptions": List<ServerService>
+ *   "subscriptions": optional List<ServerService>
  * }
  */
 class ServerSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   List<ServerService> subscriptions;
 
-  ServerSetSubscriptionsParams(this.subscriptions);
+  ServerSetSubscriptionsParams({this.subscriptions}) {
+    if (subscriptions == null) {
+      subscriptions = <ServerService>[];
+    }
+  }
 
   factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        subscriptions = <ServerService>[];
       }
-      return new ServerSetSubscriptionsParams(subscriptions);
+      return new ServerSetSubscriptionsParams(subscriptions: 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()).toList();
+    if (subscriptions.isNotEmpty) {
+      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());
 
@@ skipping 233 matching lines @@
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getErrors result
  *
  * {
- *   "errors": List<AnalysisError>
+ *   "errors": optional List<AnalysisError>
  * }
  */
 class AnalysisGetErrorsResult implements HasToJson {
   /**
    * The errors associated with the file.
    */
   List<AnalysisError> errors;
 
-  AnalysisGetErrorsResult(this.errors);
+  AnalysisGetErrorsResult({this.errors}) {
+    if (errors == null) {
+      errors = <AnalysisError>[];
+    }
+  }
 
   factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        errors = <AnalysisError>[];
       }
-      return new AnalysisGetErrorsResult(errors);
+      return new AnalysisGetErrorsResult(errors: 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()).toList();
+    if (errors.isNotEmpty) {
+      result["errors"] = errors.map((AnalysisError value) => value.toJson()).toList();
+    }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 91 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.getHover result
  *
  * {
- *   "hovers": List<HoverInformation>
+ *   "hovers": optional List<HoverInformation>
  * }
  */
 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
+   * The hover information associated with the location. The list will be
+   * omitted 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).
    */
   List<HoverInformation> hovers;
 
-  AnalysisGetHoverResult(this.hovers);
+  AnalysisGetHoverResult({this.hovers}) {
+    if (hovers == null) {
+      hovers = <HoverInformation>[];
+    }
+  }
 
   factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<HoverInformation> hovers;
       if (json.containsKey("hovers")) {
         hovers = jsonDecoder._decodeList(jsonPath + ".hovers", json["hovers"], (String jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "hovers");
+        hovers = <HoverInformation>[];
       }
-      return new AnalysisGetHoverResult(hovers);
+      return new AnalysisGetHoverResult(hovers: hovers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result");
     }
   }
 
   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()).toList();
+    if (hovers.isNotEmpty) {
+      result["hovers"] = hovers.map((HoverInformation value) => value.toJson()).toList();
+    }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 10 matching lines @@
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, hovers.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setAnalysisRoots params
  *
  * {
- *   "included": List<FilePath>
- *   "excluded": List<FilePath>
+ *   "included": optional List<FilePath>
+ *   "excluded": optional List<FilePath>
  * }
  */
 class AnalysisSetAnalysisRootsParams implements HasToJson {
   /**
    * A list of the files and directories that should be analyzed.
    */
   List<String> included;
 
   /**
    * A list of the files and directories within the included directories that
    * should not be analyzed.
    */
   List<String> excluded;
 
-  AnalysisSetAnalysisRootsParams(this.included, this.excluded);
+  AnalysisSetAnalysisRootsParams({this.included, this.excluded}) {
+    if (included == null) {
+      included = <String>[];
+    }
+    if (excluded == null) {
+      excluded = <String>[];
+    }
+  }
 
   factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> included;
       if (json.containsKey("included")) {
         included = jsonDecoder._decodeList(jsonPath + ".included", json["included"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "included");
+        included = <String>[];
       }
       List<String> excluded;
       if (json.containsKey("excluded")) {
         excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "excluded");
+        excluded = <String>[];
       }
-      return new AnalysisSetAnalysisRootsParams(included, excluded);
+      return new AnalysisSetAnalysisRootsParams(included: included, excluded: excluded);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params");
     }
   }
 
   factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
     return new AnalysisSetAnalysisRootsParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["included"] = included;
-    result["excluded"] = excluded;
+    if (included.isNotEmpty) {
+      result["included"] = included;
+    }
+    if (excluded.isNotEmpty) {
+      result["excluded"] = excluded;
+    }
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.setAnalysisRoots", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 12 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, included.hashCode);
     hash = _JenkinsSmiHash.combine(hash, excluded.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.setPriorityFiles params
  *
  * {
- *   "files": List<FilePath>
+ *   "files": optional List<FilePath>
  * }
  */
 class AnalysisSetPriorityFilesParams implements HasToJson {
   /**
    * The files that are to be a priority for analysis.
    */
   List<String> files;
 
-  AnalysisSetPriorityFilesParams(this.files);
+  AnalysisSetPriorityFilesParams({this.files}) {
+    if (files == null) {
+      files = <String>[];
+    }
+  }
 
   factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "files");
+        files = <String>[];
       }
-      return new AnalysisSetPriorityFilesParams(files);
+      return new AnalysisSetPriorityFilesParams(files: files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params");
     }
   }
 
   factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
     return new AnalysisSetPriorityFilesParams.fromJson(
         new RequestDecoder(request), "params", request.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["files"] = files;
+    if (files.isNotEmpty) {
+      result["files"] = files;
+    }
     return result;
   }
 
   Request toRequest(String id) {
     return new Request(id, "analysis.setPriorityFiles", toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 211 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, options.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.errors params
  *
  * {
  *   "file": FilePath
- *   "errors": List<AnalysisError>
+ *   "errors": optional List<AnalysisError>
  * }
  */
 class AnalysisErrorsParams implements HasToJson {
   /**
    * The file containing the errors.
    */
   String file;
 
   /**
    * The errors contained in the file.
    */
   List<AnalysisError> errors;
 
-  AnalysisErrorsParams(this.file, this.errors);
+  AnalysisErrorsParams(this.file, {this.errors}) {
+    if (errors == null) {
+      errors = <AnalysisError>[];
+    }
+  }
 
   factory AnalysisErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       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");
+        errors = <AnalysisError>[];
       }
-      return new AnalysisErrorsParams(file, errors);
+      return new AnalysisErrorsParams(file, errors: errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.errors params");
     }
   }
 
   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()).toList();
+    if (errors.isNotEmpty) {
+      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 &&
           _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, errors.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.flushResults params
  *
  * {
- *   "files": List<FilePath>
+ *   "files": optional List<FilePath>
  * }
  */
 class AnalysisFlushResultsParams implements HasToJson {
   /**
    * The files that are no longer being analyzed.
    */
   List<String> files;
 
-  AnalysisFlushResultsParams(this.files);
+  AnalysisFlushResultsParams({this.files}) {
+    if (files == null) {
+      files = <String>[];
+    }
+  }
 
   factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "files");
+        files = <String>[];
       }
-      return new AnalysisFlushResultsParams(files);
+      return new AnalysisFlushResultsParams(files: files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params");
     }
   }
 
   factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
     return new AnalysisFlushResultsParams.fromJson(
         new ResponseDecoder(), "params", notification.params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["files"] = files;
+    if (files.isNotEmpty) {
+      result["files"] = files;
+    }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is AnalysisFlushResultsParams) {
       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.folding params
  *
  * {
  *   "file": FilePath
- *   "regions": List<FoldingRegion>
+ *   "regions": optional List<FoldingRegion>
  * }
  */
 class AnalysisFoldingParams implements HasToJson {
   /**
    * The file containing the folding regions.
    */
   String file;
 
   /**
    * The folding regions contained in the file.
    */
   List<FoldingRegion> regions;
 
-  AnalysisFoldingParams(this.file, this.regions);
+  AnalysisFoldingParams(this.file, {this.regions}) {
+    if (regions == null) {
+      regions = <FoldingRegion>[];
+    }
+  }
 
   factory AnalysisFoldingParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<FoldingRegion> regions;
       if (json.containsKey("regions")) {
         regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "regions");
+        regions = <FoldingRegion>[];
       }
-      return new AnalysisFoldingParams(file, regions);
+      return new AnalysisFoldingParams(file, regions: regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.folding params");
     }
   }
 
   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()).toList();
+    if (regions.isNotEmpty) {
+      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 &&
           _listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.highlights params
  *
  * {
  *   "file": FilePath
- *   "regions": List<HighlightRegion>
+ *   "regions": optional List<HighlightRegion>
  * }
  */
 class AnalysisHighlightsParams implements HasToJson {
   /**
    * The file containing the highlight regions.
    */
   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
    * particular region.
    */
   List<HighlightRegion> regions;
 
-  AnalysisHighlightsParams(this.file, this.regions);
+  AnalysisHighlightsParams(this.file, {this.regions}) {
+    if (regions == null) {
+      regions = <HighlightRegion>[];
+    }
+  }
 
   factory AnalysisHighlightsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<HighlightRegion> regions;
       if (json.containsKey("regions")) {
         regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "regions");
+        regions = <HighlightRegion>[];
       }
-      return new AnalysisHighlightsParams(file, regions);
+      return new AnalysisHighlightsParams(file, regions: regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params");
     }
   }
 
   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()).toList();
+    if (regions.isNotEmpty) {
+      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 &&
           _listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.navigation params
  *
  * {
  *   "file": FilePath
- *   "regions": List<NavigationRegion>
+ *   "regions": optional List<NavigationRegion>
  * }
  */
 class AnalysisNavigationParams implements HasToJson {
   /**
    * The file containing the navigation regions.
    */
   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
    * compiled against multiple versions of a package. Note that the navigation
    * regions that are returned do not overlap other navigation regions.
    */
   List<NavigationRegion> regions;
 
-  AnalysisNavigationParams(this.file, this.regions);
+  AnalysisNavigationParams(this.file, {this.regions}) {
+    if (regions == null) {
+      regions = <NavigationRegion>[];
+    }
+  }
 
   factory AnalysisNavigationParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<NavigationRegion> regions;
       if (json.containsKey("regions")) {
         regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "regions");
+        regions = <NavigationRegion>[];
       }
-      return new AnalysisNavigationParams(file, regions);
+      return new AnalysisNavigationParams(file, regions: regions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params");
     }
   }
 
   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()).toList();
+    if (regions.isNotEmpty) {
+      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 &&
           _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b);
     }
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.occurrences params
  *
  * {
  *   "file": FilePath
- *   "occurrences": List<Occurrences>
+ *   "occurrences": optional List<Occurrences>
  * }
  */
 class AnalysisOccurrencesParams implements HasToJson {
   /**
    * The file in which the references occur.
    */
   String file;
 
   /**
    * The occurrences of references to elements within the file.
    */
   List<Occurrences> occurrences;
 
-  AnalysisOccurrencesParams(this.file, this.occurrences);
+  AnalysisOccurrencesParams(this.file, {this.occurrences}) {
+    if (occurrences == null) {
+      occurrences = <Occurrences>[];
+    }
+  }
 
   factory AnalysisOccurrencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<Occurrences> occurrences;
       if (json.containsKey("occurrences")) {
         occurrences = jsonDecoder._decodeList(jsonPath + ".occurrences", json["occurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "occurrences");
+        occurrences = <Occurrences>[];
       }
-      return new AnalysisOccurrencesParams(file, occurrences);
+      return new AnalysisOccurrencesParams(file, occurrences: occurrences);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params");
     }
   }
 
   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()).toList();
+    if (occurrences.isNotEmpty) {
+      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 86 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, outline.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * analysis.overrides params
  *
  * {
  *   "file": FilePath
- *   "overrides": List<Override>
+ *   "overrides": optional List<Override>
  * }
  */
 class AnalysisOverridesParams implements HasToJson {
   /**
    * The file with which the overrides are associated.
    */
   String file;
 
   /**
    * The overrides associated with the file.
    */
   List<Override> overrides;
 
-  AnalysisOverridesParams(this.file, this.overrides);
+  AnalysisOverridesParams(this.file, {this.overrides}) {
+    if (overrides == null) {
+      overrides = <Override>[];
+    }
+  }
 
   factory AnalysisOverridesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       List<Override> overrides;
       if (json.containsKey("overrides")) {
         overrides = jsonDecoder._decodeList(jsonPath + ".overrides", json["overrides"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "overrides");
+        overrides = <Override>[];
       }
-      return new AnalysisOverridesParams(file, overrides);
+      return new AnalysisOverridesParams(file, overrides: overrides);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params");
     }
   }
 
   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()).toList();
+    if (overrides.isNotEmpty) {
+      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 158 matching lines @@
   }
 }
 
 /**
  * completion.results params
  *
  * {
  *   "id": CompletionId
  *   "replacementOffset": int
  *   "replacementLength": int
- *   "results": List<CompletionSuggestion>
+ *   "results": optional List<CompletionSuggestion>
  *   "last": bool
  * }
  */
 class CompletionResultsParams implements HasToJson {
   /**
    * The id associated with the completion.
    */
   String id;
 
   /**
@@ skipping 19 matching lines @@
    * make additional requests.
    */
   List<CompletionSuggestion> results;
 
   /**
    * True if this is that last set of results that will be returned for the
    * indicated completion.
    */
   bool last;
 
-  CompletionResultsParams(this.id, this.replacementOffset, this.replacementLength, this.results, this.last);
+  CompletionResultsParams(this.id, this.replacementOffset, this.replacementLength, this.last, {this.results}) {
+    if (results == null) {
+      results = <CompletionSuggestion>[];
+    }
+  }
 
   factory CompletionResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       int replacementOffset;
       if (json.containsKey("replacementOffset")) {
         replacementOffset = jsonDecoder._decodeInt(jsonPath + ".replacementOffset", json["replacementOffset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacementOffset");
       }
       int replacementLength;
       if (json.containsKey("replacementLength")) {
         replacementLength = jsonDecoder._decodeInt(jsonPath + ".replacementLength", json["replacementLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacementLength");
       }
       List<CompletionSuggestion> results;
       if (json.containsKey("results")) {
         results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "results");
+        results = <CompletionSuggestion>[];
       }
       bool last;
       if (json.containsKey("last")) {
         last = jsonDecoder._decodeBool(jsonPath + ".last", json["last"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "last");
       }
-      return new CompletionResultsParams(id, replacementOffset, replacementLength, results, last);
+      return new CompletionResultsParams(id, replacementOffset, replacementLength, last, results: results);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.results params");
     }
   }
 
   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()).toList();
+    if (results.isNotEmpty) {
+      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 693 matching lines @@
    * 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.
    */
   List<TypeHierarchyItem> hierarchyItems;
 
-  SearchGetTypeHierarchyResult({this.hierarchyItems});
+  SearchGetTypeHierarchyResult({this.hierarchyItems}) {
+    if (hierarchyItems == null) {
+      hierarchyItems = <TypeHierarchyItem>[];
+    }
+  }
 
   factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<TypeHierarchyItem> hierarchyItems;
       if (json.containsKey("hierarchyItems")) {
         hierarchyItems = jsonDecoder._decodeList(jsonPath + ".hierarchyItems", json["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        hierarchyItems = <TypeHierarchyItem>[];
       }
       return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result");
     }
   }
 
   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) {
+    if (hierarchyItems.isNotEmpty) {
       result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson()).toList();
     }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
@@ skipping 13 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, hierarchyItems.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * search.results params
  *
  * {
  *   "id": SearchId
- *   "results": List<SearchResult>
+ *   "results": optional List<SearchResult>
  *   "last": bool
  * }
  */
 class SearchResultsParams implements HasToJson {
   /**
    * The id associated with the search.
    */
   String id;
 
   /**
    * The search results being reported.
    */
   List<SearchResult> results;
 
   /**
    * True if this is that last set of results that will be returned for the
    * indicated search.
    */
   bool last;
 
-  SearchResultsParams(this.id, this.results, this.last);
+  SearchResultsParams(this.id, this.last, {this.results}) {
+    if (results == null) {
+      results = <SearchResult>[];
+    }
+  }
 
   factory SearchResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "id");
       }
       List<SearchResult> results;
       if (json.containsKey("results")) {
         results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "results");
+        results = <SearchResult>[];
       }
       bool last;
       if (json.containsKey("last")) {
         last = jsonDecoder._decodeBool(jsonPath + ".last", json["last"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "last");
       }
-      return new SearchResultsParams(id, results, last);
+      return new SearchResultsParams(id, last, results: results);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.results params");
     }
   }
 
   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()).toList();
+    if (results.isNotEmpty) {
+      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 107 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     hash = _JenkinsSmiHash.combine(hash, length.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAssists result
  *
  * {
- *   "assists": List<SourceChange>
+ *   "assists": optional List<SourceChange>
  * }
  */
 class EditGetAssistsResult implements HasToJson {
   /**
    * The assists that are available at the given location.
    */
   List<SourceChange> assists;
 
-  EditGetAssistsResult(this.assists);
+  EditGetAssistsResult({this.assists}) {
+    if (assists == null) {
+      assists = <SourceChange>[];
+    }
+  }
 
   factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        assists = <SourceChange>[];
       }
-      return new EditGetAssistsResult(assists);
+      return new EditGetAssistsResult(assists: 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()).toList();
+    if (assists.isNotEmpty) {
+      result["assists"] = assists.map((SourceChange value) => value.toJson()).toList();
+    }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 106 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
     hash = _JenkinsSmiHash.combine(hash, length.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getAvailableRefactorings result
  *
  * {
- *   "kinds": List<RefactoringKind>
+ *   "kinds": optional List<RefactoringKind>
  * }
  */
 class EditGetAvailableRefactoringsResult implements HasToJson {
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   List<RefactoringKind> kinds;
 
-  EditGetAvailableRefactoringsResult(this.kinds);
+  EditGetAvailableRefactoringsResult({this.kinds}) {
+    if (kinds == null) {
+      kinds = <RefactoringKind>[];
+    }
+  }
 
   factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        kinds = <RefactoringKind>[];
       }
-      return new EditGetAvailableRefactoringsResult(kinds);
+      return new EditGetAvailableRefactoringsResult(kinds: 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()).toList();
+    if (kinds.isNotEmpty) {
+      result["kinds"] = kinds.map((RefactoringKind value) => value.toJson()).toList();
+    }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 91 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": optional List<ErrorFixes>
  * }
  */
 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;
 
-  EditGetFixesResult(this.fixes);
+  EditGetFixesResult({this.fixes}) {
+    if (fixes == null) {
+      fixes = <ErrorFixes>[];
+    }
+  }
 
   factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ErrorFixes> fixes;
       if (json.containsKey("fixes")) {
         fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new ErrorFixes.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "fixes");
+        fixes = <ErrorFixes>[];
       }
-      return new EditGetFixesResult(fixes);
+      return new EditGetFixesResult(fixes: 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();
+    if (fixes.isNotEmpty) {
+      result["fixes"] = fixes.map((ErrorFixes value) => value.toJson()).toList();
+    }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
@@ skipping 156 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, validateOnly.hashCode);
     hash = _JenkinsSmiHash.combine(hash, options.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * edit.getRefactoring result
  *
  * {
- *   "status": List<RefactoringProblem>
+ *   "status": optional List<RefactoringProblem>
  *   "feedback": optional object
  *   "change": optional SourceChange
  *   "potentialEdits": optional List<String>
  * }
  */
 class EditGetRefactoringResult implements HasToJson {
   /**
    * The status of the refactoring. The array will be empty if there are no
    * known problems.
    */
@@ skipping 18 matching lines @@
   /**
    * The ids of source edits that are not known to be valid. An edit is not
    * known to be valid if there was insufficient type information for the
    * server to be able to determine whether or not the code needs to be
    * modified, such as when a member is being renamed and there is a reference
    * to a member from an unknown type. This field will be omitted if the change
    * field is omitted or if there are no potential edits for the refactoring.
    */
   List<String> potentialEdits;
 
-  EditGetRefactoringResult(this.status, {this.feedback, this.change, this.potentialEdits});
+  EditGetRefactoringResult({this.status, this.feedback, this.change, this.potentialEdits}) {
+    if (status == null) {
+      status = <RefactoringProblem>[];
+    }
+    if (potentialEdits == null) {
+      potentialEdits = <String>[];
+    }
+  }
 
   factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<RefactoringProblem> status;
       if (json.containsKey("status")) {
         status = jsonDecoder._decodeList(jsonPath + ".status", json["status"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "status");
+        status = <RefactoringProblem>[];
       }
       Object feedback;
       if (json.containsKey("feedback")) {
         feedback = json["feedback"];
       }
       SourceChange change;
       if (json.containsKey("change")) {
         change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", json["change"]);
       }
       List<String> potentialEdits;
       if (json.containsKey("potentialEdits")) {
         potentialEdits = jsonDecoder._decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder._decodeString);
+      } else {
+        potentialEdits = <String>[];
       }
-      return new EditGetRefactoringResult(status, feedback: feedback, change: change, potentialEdits: potentialEdits);
+      return new EditGetRefactoringResult(status: status, feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result");
     }
   }
 
   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()).toList();
+    if (status.isNotEmpty) {
+      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) {
+    if (potentialEdits.isNotEmpty) {
       result["potentialEdits"] = potentialEdits;
     }
     return result;
   }
 
   Response toResponse(String id) {
     return new Response(id, result: toJson());
   }
 
   @override
@@ skipping 395 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, file.hashCode);
     hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * debug.setSubscriptions params
  *
  * {
- *   "subscriptions": List<DebugService>
+ *   "subscriptions": optional List<DebugService>
  * }
  */
 class DebugSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   List<DebugService> subscriptions;
 
-  DebugSetSubscriptionsParams(this.subscriptions);
+  DebugSetSubscriptionsParams({this.subscriptions}) {
+    if (subscriptions == null) {
+      subscriptions = <DebugService>[];
+    }
+  }
 
   factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        subscriptions = <DebugService>[];
       }
-      return new DebugSetSubscriptionsParams(subscriptions);
+      return new DebugSetSubscriptionsParams(subscriptions: 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()).toList();
+    if (subscriptions.isNotEmpty) {
+      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());
 
@@ skipping 10 matching lines @@
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * debug.launchData params
  *
  * {
- *   "executables": List<ExecutableFile>
+ *   "executables": optional List<ExecutableFile>
  *   "dartToHtml": Map<FilePath, List<FilePath>>
  *   "htmlToDart": Map<FilePath, List<FilePath>>
  * }
  */
 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.
    */
   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.
    */
   Map<String, List<String>> dartToHtml;
 
   /**
    * A mapping from the paths of HTML files that reference Dart files to a list
    * of the Dart files they reference.
    */
   Map<String, List<String>> htmlToDart;
 
-  DebugLaunchDataParams(this.executables, this.dartToHtml, this.htmlToDart);
+  DebugLaunchDataParams(this.dartToHtml, this.htmlToDart, {this.executables}) {
+    if (executables == null) {
+      executables = <ExecutableFile>[];
+    }
+  }
 
   factory DebugLaunchDataParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<ExecutableFile> executables;
       if (json.containsKey("executables")) {
         executables = jsonDecoder._decodeList(jsonPath + ".executables", json["executables"], (String jsonPath, Object json) => new ExecutableFile.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "executables");
+        executables = <ExecutableFile>[];
       }
       Map<String, List<String>> dartToHtml;
       if (json.containsKey("dartToHtml")) {
         dartToHtml = jsonDecoder._decodeMap(jsonPath + ".dartToHtml", json["dartToHtml"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "dartToHtml");
       }
       Map<String, List<String>> htmlToDart;
       if (json.containsKey("htmlToDart")) {
         htmlToDart = jsonDecoder._decodeMap(jsonPath + ".htmlToDart", json["htmlToDart"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "htmlToDart");
       }
-      return new DebugLaunchDataParams(executables, dartToHtml, htmlToDart);
+      return new DebugLaunchDataParams(dartToHtml, htmlToDart, executables: executables);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.launchData params");
     }
   }
 
   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()).toList();
+    if (executables.isNotEmpty) {
+      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 459 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, analysisTarget.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ChangeContentOverlay
  *
  * {
  *   "type": "change"
- *   "edits": List<SourceEdit>
+ *   "edits": optional List<SourceEdit>
  * }
  */
 class ChangeContentOverlay implements HasToJson {
   /**
    * The edits to be applied to the file.
    */
   List<SourceEdit> edits;
 
-  ChangeContentOverlay(this.edits);
+  ChangeContentOverlay({this.edits}) {
+    if (edits == null) {
+      edits = <SourceEdit>[];
+    }
+  }
 
   factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       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");
+        edits = <SourceEdit>[];
       }
-      return new ChangeContentOverlay(edits);
+      return new ChangeContentOverlay(edits: 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()).toList();
+    if (edits.isNotEmpty) {
+      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 180 matching lines @@
    * argument list.
    */
   String parameterName;
 
   /**
    * The type of the options parameter being suggested. This field is omitted
    * if the parameterName field is omitted.
    */
   String parameterType;
 
-  CompletionSuggestion(this.kind, this.relevance, this.completion, this.selectionOffset, this.selectionLength, this.isDeprecated, this.isPotential, {this.docSummary, this.docComplete, this.declaringType, this.returnType, this.parameterNames, this.parameterTypes, this.requiredParameterCount, this.positionalParameterCount, this.parameterName, this.parameterType});
+  CompletionSuggestion(this.kind, this.relevance, this.completion, this.selectionOffset, this.selectionLength, this.isDeprecated, this.isPotential, {this.docSummary, this.docComplete, this.declaringType, this.returnType, this.parameterNames, this.parameterTypes, this.requiredParameterCount, this.positionalParameterCount, this.parameterName, this.parameterType}) {
+    if (parameterNames == null) {
+      parameterNames = <String>[];
+    }
+    if (parameterTypes == null) {
+      parameterTypes = <String>[];
+    }
+  }
 
   factory CompletionSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       CompletionSuggestionKind kind;
       if (json.containsKey("kind")) {
         kind = new CompletionSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
@@ skipping 47 matching lines @@
       if (json.containsKey("declaringType")) {
         declaringType = jsonDecoder._decodeString(jsonPath + ".declaringType", json["declaringType"]);
       }
       String returnType;
       if (json.containsKey("returnType")) {
         returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
       }
       List<String> parameterNames;
       if (json.containsKey("parameterNames")) {
         parameterNames = jsonDecoder._decodeList(jsonPath + ".parameterNames", json["parameterNames"], jsonDecoder._decodeString);
+      } else {
+        parameterNames = <String>[];
       }
       List<String> parameterTypes;
       if (json.containsKey("parameterTypes")) {
         parameterTypes = jsonDecoder._decodeList(jsonPath + ".parameterTypes", json["parameterTypes"], jsonDecoder._decodeString);
+      } else {
+        parameterTypes = <String>[];
       }
       int requiredParameterCount;
       if (json.containsKey("requiredParameterCount")) {
         requiredParameterCount = jsonDecoder._decodeInt(jsonPath + ".requiredParameterCount", json["requiredParameterCount"]);
       }
       int positionalParameterCount;
       if (json.containsKey("positionalParameterCount")) {
         positionalParameterCount = jsonDecoder._decodeInt(jsonPath + ".positionalParameterCount", json["positionalParameterCount"]);
       }
       String parameterName;
@@ skipping 24 matching lines @@
     }
     if (docComplete != null) {
       result["docComplete"] = docComplete;
     }
     if (declaringType != null) {
       result["declaringType"] = declaringType;
     }
     if (returnType != null) {
       result["returnType"] = returnType;
     }
-    if (parameterNames != null) {
+    if (parameterNames.isNotEmpty) {
       result["parameterNames"] = parameterNames;
     }
-    if (parameterTypes != null) {
+    if (parameterTypes.isNotEmpty) {
       result["parameterTypes"] = parameterTypes;
     }
     if (requiredParameterCount != null) {
       result["requiredParameterCount"] = requiredParameterCount;
     }
     if (positionalParameterCount != null) {
       result["positionalParameterCount"] = positionalParameterCount;
     }
     if (parameterName != null) {
       result["parameterName"] = parameterName;
@@ skipping 620 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, data.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * ErrorFixes
  *
  * {
  *   "error": AnalysisError
- *   "fixes": List<SourceChange>
+ *   "fixes": optional 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);
+  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");
+        fixes = <SourceChange>[];
       }
-      return new ErrorFixes(error, 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();
+    if (fixes.isNotEmpty) {
+      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 892 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, propagatedType.hashCode);
     hash = _JenkinsSmiHash.combine(hash, staticType.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * LinkedEditGroup
  *
  * {
- *   "positions": List<Position>
+ *   "positions": optional List<Position>
  *   "length": int
- *   "suggestions": List<LinkedEditSuggestion>
+ *   "suggestions": optional List<LinkedEditSuggestion>
  * }
  */
 class LinkedEditGroup implements HasToJson {
   /**
    * The positions of the regions that should be edited simultaneously.
    */
   List<Position> positions;
 
   /**
    * The length of the regions that should be edited simultaneously.
    */
   int length;
 
   /**
    * Pre-computed suggestions for what every region might want to be changed
    * to.
    */
   List<LinkedEditSuggestion> suggestions;
 
-  LinkedEditGroup(this.positions, this.length, this.suggestions);
+  LinkedEditGroup(this.length, {this.positions, this.suggestions}) {
+    if (positions == null) {
+      positions = <Position>[];
+    }
+    if (suggestions == null) {
+      suggestions = <LinkedEditSuggestion>[];
+    }
+  }
 
   factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<Position> positions;
       if (json.containsKey("positions")) {
         positions = jsonDecoder._decodeList(jsonPath + ".positions", json["positions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "positions");
+        positions = <Position>[];
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<LinkedEditSuggestion> suggestions;
       if (json.containsKey("suggestions")) {
         suggestions = jsonDecoder._decodeList(jsonPath + ".suggestions", json["suggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "suggestions");
+        suggestions = <LinkedEditSuggestion>[];
       }
-      return new LinkedEditGroup(positions, length, suggestions);
+      return new LinkedEditGroup(length, positions: positions, suggestions: suggestions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["positions"] = positions.map((Position value) => value.toJson()).toList();
+    if (positions.isNotEmpty) {
+      result["positions"] = positions.map((Position value) => value.toJson()).toList();
+    }
     result["length"] = length;
-    result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => value.toJson()).toList();
+    if (suggestions.isNotEmpty) {
+      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 269 matching lines @@
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * NavigationRegion
  *
  * {
  *   "offset": int
  *   "length": int
- *   "targets": List<Element>
+ *   "targets": optional List<Element>
  * }
  */
 class NavigationRegion implements HasToJson {
   /**
    * The offset of the region from which the user can navigate.
    */
   int offset;
 
   /**
    * The length of the region from which the user can navigate.
    */
   int length;
 
   /**
    * The elements to which the given region is bound. By opening the
    * declaration of the elements, clients can implement one form of navigation.
    */
   List<Element> targets;
 
-  NavigationRegion(this.offset, this.length, this.targets);
+  NavigationRegion(this.offset, this.length, {this.targets}) {
+    if (targets == null) {
+      targets = <Element>[];
+    }
+  }
 
   factory NavigationRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<Element> targets;
       if (json.containsKey("targets")) {
         targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "targets");
+        targets = <Element>[];
       }
-      return new NavigationRegion(offset, length, targets);
+      return new NavigationRegion(offset, length, targets: 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()).toList();
+    if (targets.isNotEmpty) {
+      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 11 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * Occurrences
  *
  * {
  *   "element": Element
- *   "offsets": List<int>
+ *   "offsets": optional List<int>
  *   "length": int
  * }
  */
 class Occurrences implements HasToJson {
   /**
    * The element that was referenced.
    */
   Element element;
 
   /**
    * The offsets of the name of the referenced element within the file.
    */
   List<int> offsets;
 
   /**
    * The length of the name of the referenced element.
    */
   int length;
 
-  Occurrences(this.element, this.offsets, this.length);
+  Occurrences(this.element, this.length, {this.offsets}) {
+    if (offsets == null) {
+      offsets = <int>[];
+    }
+  }
 
   factory Occurrences.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
         offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "offsets");
+        offsets = <int>[];
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
-      return new Occurrences(element, offsets, length);
+      return new Occurrences(element, length, offsets: offsets);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Occurrences");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
-    result["offsets"] = offsets;
+    if (offsets.isNotEmpty) {
+      result["offsets"] = offsets;
+    }
     result["length"] = length;
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is Occurrences) {
@@ skipping 42 matching lines @@
    * The length of the element.
    */
   int length;
 
   /**
    * The children of the node. The field will be omitted if the node has no
    * children.
    */
   List<Outline> children;
 
-  Outline(this.element, this.offset, this.length, {this.children});
+  Outline(this.element, this.offset, this.length, {this.children}) {
+    if (children == null) {
+      children = <Outline>[];
+    }
+  }
 
   factory Outline.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<Outline> children;
       if (json.containsKey("children")) {
         children = jsonDecoder._decodeList(jsonPath + ".children", json["children"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        children = <Outline>[];
       }
       return new Outline(element, offset, length, children: children);
     } else {
       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) {
+    if (children.isNotEmpty) {
       result["children"] = children.map((Outline value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
@@ skipping 45 matching lines @@
    */
   OverriddenMember superclassMember;
 
   /**
    * The members inherited from interfaces that are overridden by the
    * overriding member. The field is omitted if there are no interface members,
    * in which case there must be a superclass member.
    */
   List<OverriddenMember> interfaceMembers;
 
-  Override(this.offset, this.length, {this.superclassMember, this.interfaceMembers});
+  Override(this.offset, this.length, {this.superclassMember, this.interfaceMembers}) {
+    if (interfaceMembers == null) {
+      interfaceMembers = <OverriddenMember>[];
+    }
+  }
 
   factory Override.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       OverriddenMember superclassMember;
       if (json.containsKey("superclassMember")) {
         superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath + ".superclassMember", json["superclassMember"]);
       }
       List<OverriddenMember> interfaceMembers;
       if (json.containsKey("interfaceMembers")) {
         interfaceMembers = jsonDecoder._decodeList(jsonPath + ".interfaceMembers", json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMember.fromJson(jsonDecoder, jsonPath, json));
+      } else {
+        interfaceMembers = <OverriddenMember>[];
       }
       return new Override(offset, length, superclassMember: superclassMember, interfaceMembers: interfaceMembers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "Override");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     if (superclassMember != null) {
       result["superclassMember"] = superclassMember.toJson();
     }
-    if (interfaceMembers != null) {
+    if (interfaceMembers.isNotEmpty) {
       result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value) => value.toJson()).toList();
     }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
@@ skipping 598 matching lines @@
   }
 }
 
 /**
  * SearchResult
  *
  * {
  *   "location": Location
  *   "kind": SearchResultKind
  *   "isPotential": bool
- *   "path": List<Element>
+ *   "path": optional List<Element>
  * }
  */
 class SearchResult implements HasToJson {
   /**
    * The location of the code that matched the search criteria.
    */
   Location location;
 
   /**
    * The kind of element that was found or the kind of reference that was
    * found.
    */
   SearchResultKind kind;
 
   /**
    * True if the result is a potential match but cannot be confirmed to be a
    * match. For example, if all references to a method m defined in some class
    * were requested, and a reference to a method m from an unknown class were
    * found, it would be marked as being a potential match.
    */
   bool isPotential;
 
   /**
    * The elements that contain the result, starting with the most immediately
    * enclosing ancestor and ending with the library.
    */
   List<Element> path;
 
-  SearchResult(this.location, this.kind, this.isPotential, this.path);
+  SearchResult(this.location, this.kind, this.isPotential, {this.path}) {
+    if (path == null) {
+      path = <Element>[];
+    }
+  }
 
   factory SearchResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "location");
       }
       SearchResultKind kind;
       if (json.containsKey("kind")) {
         kind = new SearchResultKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       bool isPotential;
       if (json.containsKey("isPotential")) {
         isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["isPotential"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isPotential");
       }
       List<Element> path;
       if (json.containsKey("path")) {
         path = jsonDecoder._decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "path");
+        path = <Element>[];
       }
-      return new SearchResult(location, kind, isPotential, path);
+      return new SearchResult(location, kind, isPotential, path: path);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "SearchResult");
     }
   }
 
   /**
    * Construct based on a value from the search engine.
    */
   factory SearchResult.fromMatch(engine.SearchMatch match) =>
       searchResultFromMatch(match);
 
   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()).toList();
+    if (path.isNotEmpty) {
+      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 149 matching lines @@
   String toString() => "ServerService.$name";
 
   String toJson() => name;
 }
 
 /**
  * SourceChange
  *
  * {
  *   "message": String
- *   "edits": List<SourceFileEdit>
- *   "linkedEditGroups": List<LinkedEditGroup>
+ *   "edits": optional List<SourceFileEdit>
+ *   "linkedEditGroups": optional List<LinkedEditGroup>
  *   "selection": optional Position
  * }
  */
 class SourceChange implements HasToJson {
   /**
    * A human-readable description of the change to be applied.
    */
   String message;
 
   /**
    * A list of the edits used to effect the change, grouped by file.
    */
   List<SourceFileEdit> edits;
 
   /**
    * A list of the linked editing groups used to customize the changes that
    * were made.
    */
   List<LinkedEditGroup> linkedEditGroups;
 
   /**
    * The position that should be selected after the edits have been applied.
    */
   Position selection;
 
-  SourceChange(this.message, this.edits, this.linkedEditGroups, {this.selection});
+  SourceChange(this.message, {this.edits, this.linkedEditGroups, this.selection}) {
+    if (edits == null) {
+      edits = <SourceFileEdit>[];
+    }
+    if (linkedEditGroups == null) {
+      linkedEditGroups = <LinkedEditGroup>[];
+    }
+  }
 
   factory SourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String message;
       if (json.containsKey("message")) {
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       List<SourceFileEdit> edits;
       if (json.containsKey("edits")) {
         edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "edits");
+        edits = <SourceFileEdit>[];
       }
       List<LinkedEditGroup> linkedEditGroups;
       if (json.containsKey("linkedEditGroups")) {
         linkedEditGroups = jsonDecoder._decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups");
+        linkedEditGroups = <LinkedEditGroup>[];
       }
       Position selection;
       if (json.containsKey("selection")) {
         selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
       }
-      return new SourceChange(message, edits, linkedEditGroups, selection: selection);
+      return new SourceChange(message, edits: edits, linkedEditGroups: 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()).toList();
-    result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson()).toList();
+    if (edits.isNotEmpty) {
+      result["edits"] = edits.map((SourceFileEdit value) => value.toJson()).toList();
+    }
+    if (linkedEditGroups.isNotEmpty) {
+      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 148 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, id.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * SourceFileEdit
  *
  * {
  *   "file": FilePath
- *   "edits": List<SourceEdit>
+ *   "edits": optional List<SourceEdit>
  * }
  */
 class SourceFileEdit implements HasToJson {
   /**
    * The file containing the code to be modified.
    */
   String file;
 
   /**
    * A list of the edits used to effect the change.
    */
   List<SourceEdit> edits;
 
-  SourceFileEdit(this.file, this.edits);
+  SourceFileEdit(this.file, {this.edits}) {
+    if (edits == null) {
+      edits = <SourceEdit>[];
+    }
+  }
 
   factory SourceFileEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       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");
+        edits = <SourceEdit>[];
       }
-      return new SourceFileEdit(file, edits);
+      return new SourceFileEdit(file, edits: 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()).toList();
+    if (edits.isNotEmpty) {
+      result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
+    }
     return result;
   }
 
   /**
    * Adds the given [Edit] to the list.
    */
   void add(SourceEdit edit) => _addEditForSource(this, edit);
 
   /**
    * Adds the given [Edit]s.
@@ skipping 23 matching lines @@
 }
 
 /**
  * TypeHierarchyItem
  *
  * {
  *   "classElement": Element
  *   "displayName": optional String
  *   "memberElement": optional Element
  *   "superclass": optional int
- *   "interfaces": List<int>
- *   "mixins": List<int>
- *   "subclasses": List<int>
+ *   "interfaces": optional List<int>
+ *   "mixins": optional List<int>
+ *   "subclasses": optional List<int>
  * }
  */
 class TypeHierarchyItem implements HasToJson {
   /**
    * The class element represented by this item.
    */
   Element classElement;
 
   /**
    * The name to be displayed for the class. This field will be omitted if the
@@ skipping 29 matching lines @@
    */
   List<int> mixins;
 
   /**
    * The indexes of the items representing the subtypes of this class. The list
    * will be empty if there are no subtypes or if this item represents a
    * supertype of the pivot type.
    */
   List<int> subclasses;
 
-  TypeHierarchyItem(this.classElement, this.interfaces, this.mixins, this.subclasses, {this.displayName, this.memberElement, this.superclass});
+  TypeHierarchyItem(this.classElement, {this.displayName, this.memberElement, this.superclass, this.interfaces, this.mixins, this.subclasses}) {
+    if (interfaces == null) {
+      interfaces = <int>[];
+    }
+    if (mixins == null) {
+      mixins = <int>[];
+    }
+    if (subclasses == null) {
+      subclasses = <int>[];
+    }
+  }
 
   factory TypeHierarchyItem.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       Element classElement;
       if (json.containsKey("classElement")) {
         classElement = new Element.fromJson(jsonDecoder, jsonPath + ".classElement", json["classElement"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "classElement");
       }
       String displayName;
       if (json.containsKey("displayName")) {
         displayName = jsonDecoder._decodeString(jsonPath + ".displayName", json["displayName"]);
       }
       Element memberElement;
       if (json.containsKey("memberElement")) {
         memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberElement", json["memberElement"]);
       }
       int superclass;
       if (json.containsKey("superclass")) {
         superclass = jsonDecoder._decodeInt(jsonPath + ".superclass", json["superclass"]);
       }
       List<int> interfaces;
       if (json.containsKey("interfaces")) {
         interfaces = jsonDecoder._decodeList(jsonPath + ".interfaces", json["interfaces"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "interfaces");
+        interfaces = <int>[];
       }
       List<int> mixins;
       if (json.containsKey("mixins")) {
         mixins = jsonDecoder._decodeList(jsonPath + ".mixins", json["mixins"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "mixins");
+        mixins = <int>[];
       }
       List<int> subclasses;
       if (json.containsKey("subclasses")) {
         subclasses = jsonDecoder._decodeList(jsonPath + ".subclasses", json["subclasses"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "subclasses");
+        subclasses = <int>[];
       }
-      return new TypeHierarchyItem(classElement, interfaces, mixins, subclasses, displayName: displayName, memberElement: memberElement, superclass: superclass);
+      return new TypeHierarchyItem(classElement, displayName: displayName, memberElement: memberElement, superclass: superclass, interfaces: interfaces, mixins: mixins, subclasses: subclasses);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem");
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["classElement"] = classElement.toJson();
     if (displayName != null) {
       result["displayName"] = displayName;
     }
     if (memberElement != null) {
       result["memberElement"] = memberElement.toJson();
     }
     if (superclass != null) {
       result["superclass"] = superclass;
     }
-    result["interfaces"] = interfaces;
-    result["mixins"] = mixins;
-    result["subclasses"] = subclasses;
+    if (interfaces.isNotEmpty) {
+      result["interfaces"] = interfaces;
+    }
+    if (mixins.isNotEmpty) {
+      result["mixins"] = mixins;
+    }
+    if (subclasses.isNotEmpty) {
+      result["subclasses"] = subclasses;
+    }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is TypeHierarchyItem) {
       return classElement == other.classElement &&
@@ skipping 18 matching lines @@
     hash = _JenkinsSmiHash.combine(hash, mixins.hashCode);
     hash = _JenkinsSmiHash.combine(hash, subclasses.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }
 
 /**
  * extractLocalVariable feedback
  *
  * {
- *   "names": List<String>
- *   "offsets": List<int>
- *   "lengths": List<int>
+ *   "names": optional List<String>
+ *   "offsets": optional List<int>
+ *   "lengths": optional List<int>
  * }
  */
 class ExtractLocalVariableFeedback implements HasToJson {
   /**
    * The proposed names for the local variable.
    */
   List<String> names;
 
   /**
    * The offsets of the expressions that would be replaced by a reference to
    * the variable.
    */
   List<int> offsets;
 
   /**
    * The lengths of the expressions that would be replaced by a reference to
    * the variable. The lengths correspond to the offsets. In other words, for a
    * given expression, if the offset of that expression is offsets[i], then the
    * length of that expression is lengths[i].
    */
   List<int> lengths;
 
-  ExtractLocalVariableFeedback(this.names, this.offsets, this.lengths);
+  ExtractLocalVariableFeedback({this.names, this.offsets, this.lengths}) {
+    if (names == null) {
+      names = <String>[];
+    }
+    if (offsets == null) {
+      offsets = <int>[];
+    }
+    if (lengths == null) {
+      lengths = <int>[];
+    }
+  }
 
   factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> names;
       if (json.containsKey("names")) {
         names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "names");
+        names = <String>[];
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
         offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "offsets");
+        offsets = <int>[];
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "lengths");
+        lengths = <int>[];
       }
-      return new ExtractLocalVariableFeedback(names, offsets, lengths);
+      return new ExtractLocalVariableFeedback(names: names, offsets: offsets, lengths: lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback");
     }
   }
 
   factory ExtractLocalVariableFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
     return new ExtractLocalVariableFeedback.fromJson(
         new ResponseDecoder(), "feedback", refactoringResult.feedback);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
-    result["names"] = names;
-    result["offsets"] = offsets;
-    result["lengths"] = lengths;
+    if (names.isNotEmpty) {
+      result["names"] = names;
+    }
+    if (offsets.isNotEmpty) {
+      result["offsets"] = offsets;
+    }
+    if (lengths.isNotEmpty) {
+      result["lengths"] = lengths;
+    }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractLocalVariableFeedback) {
       return _listEqual(names, other.names, (String a, String b) => a == b) &&
@@ skipping 93 matching lines @@
   }
 }
 
 /**
  * extractMethod feedback
  *
  * {
  *   "offset": int
  *   "length": int
  *   "returnType": String
- *   "names": List<String>
+ *   "names": optional List<String>
  *   "canCreateGetter": bool
- *   "parameters": List<RefactoringMethodParameter>
+ *   "parameters": optional List<RefactoringMethodParameter>
  *   "occurrences": int
- *   "offsets": List<int>
- *   "lengths": List<int>
+ *   "offsets": optional List<int>
+ *   "lengths": optional List<int>
  * }
  */
 class ExtractMethodFeedback implements HasToJson {
   /**
    * The offset to the beginning of the expression or statements that will be
    * extracted.
    */
   int offset;
 
   /**
@@ skipping 34 matching lines @@
 
   /**
    * The lengths of the expressions or statements that would be replaced by an
    * invocation of the method. The lengths correspond to the offsets. In other
    * words, for a given expression (or block of statements), if the offset of
    * that expression is offsets[i], then the length of that expression is
    * lengths[i].
    */
   List<int> lengths;
 
-  ExtractMethodFeedback(this.offset, this.length, this.returnType, this.names, this.canCreateGetter, this.parameters, this.occurrences, this.offsets, this.lengths);
+  ExtractMethodFeedback(this.offset, this.length, this.returnType, this.canCreateGetter, this.occurrences, {this.names, this.parameters, this.offsets, this.lengths}) {
+    if (names == null) {
+      names = <String>[];
+    }
+    if (parameters == null) {
+      parameters = <RefactoringMethodParameter>[];
+    }
+    if (offsets == null) {
+      offsets = <int>[];
+    }
+    if (lengths == null) {
+      lengths = <int>[];
+    }
+  }
 
   factory ExtractMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       String returnType;
       if (json.containsKey("returnType")) {
         returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "returnType");
       }
       List<String> names;
       if (json.containsKey("names")) {
         names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "names");
+        names = <String>[];
       }
       bool canCreateGetter;
       if (json.containsKey("canCreateGetter")) {
         canCreateGetter = jsonDecoder._decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "canCreateGetter");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
         parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "parameters");
+        parameters = <RefactoringMethodParameter>[];
       }
       int occurrences;
       if (json.containsKey("occurrences")) {
         occurrences = jsonDecoder._decodeInt(jsonPath + ".occurrences", json["occurrences"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
         offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "offsets");
+        offsets = <int>[];
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "lengths");
+        lengths = <int>[];
       }
-      return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, occurrences, offsets, lengths);
+      return new ExtractMethodFeedback(offset, length, returnType, canCreateGetter, occurrences, names: names, parameters: parameters, offsets: offsets, lengths: lengths);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback");
     }
   }
 
   factory ExtractMethodFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
     return new ExtractMethodFeedback.fromJson(
         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;
+    if (names.isNotEmpty) {
+      result["names"] = names;
+    }
     result["canCreateGetter"] = canCreateGetter;
-    result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
+    if (parameters.isNotEmpty) {
+      result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson()).toList();
+    }
     result["occurrences"] = occurrences;
-    result["offsets"] = offsets;
-    result["lengths"] = lengths;
+    if (offsets.isNotEmpty) {
+      result["offsets"] = offsets;
+    }
+    if (lengths.isNotEmpty) {
+      result["lengths"] = lengths;
+    }
     return result;
   }
 
   @override
   String toString() => JSON.encode(toJson());
 
   @override
   bool operator==(other) {
     if (other is ExtractMethodFeedback) {
       return offset == other.offset &&
@@ skipping 25 matching lines @@
   }
 }
 
 /**
  * extractMethod options
  *
  * {
  *   "returnType": String
  *   "createGetter": bool
  *   "name": String
- *   "parameters": List<RefactoringMethodParameter>
+ *   "parameters": optional List<RefactoringMethodParameter>
  *   "extractAll": bool
  * }
  */
 class ExtractMethodOptions implements HasToJson {
   /**
    * The return type that should be defined for the method.
    */
   String returnType;
 
   /**
@@ skipping 21 matching lines @@
    */
   List<RefactoringMethodParameter> parameters;
 
   /**
    * True if all occurrences of the expression or statements should be replaced
    * by an invocation of the method. The expression or statements used to
    * initiate the refactoring will always be replaced.
    */
   bool extractAll;
 
-  ExtractMethodOptions(this.returnType, this.createGetter, this.name, this.parameters, this.extractAll);
+  ExtractMethodOptions(this.returnType, this.createGetter, this.name, this.extractAll, {this.parameters}) {
+    if (parameters == null) {
+      parameters = <RefactoringMethodParameter>[];
+    }
+  }
 
   factory ExtractMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       String returnType;
       if (json.containsKey("returnType")) {
         returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "returnType");
       }
       bool createGetter;
       if (json.containsKey("createGetter")) {
         createGetter = jsonDecoder._decodeBool(jsonPath + ".createGetter", json["createGetter"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "createGetter");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       List<RefactoringMethodParameter> parameters;
       if (json.containsKey("parameters")) {
         parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
       } else {
-        throw jsonDecoder.missingKey(jsonPath, "parameters");
+        parameters = <RefactoringMethodParameter>[];
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
         extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "extractAll");
       }
-      return new ExtractMethodOptions(returnType, createGetter, name, parameters, extractAll);
+      return new ExtractMethodOptions(returnType, createGetter, name, extractAll, parameters: parameters);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "extractMethod options");
     }
   }
 
   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()).toList();
+    if (parameters.isNotEmpty) {
+      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 228 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }