Allow null as a synonym for {} when decoding JSON objects.

pkg/analysis_server/lib/src/generated_protocol.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // This file has been automatically generated.  Please do not edit it manually.
 // To regenerate the file, use the script
 // "pkg/analysis_server/spec/generate_files".
 
 part of protocol2;
 
 /**
  * server.getVersion result
  *
  * {
  *   "version": String
  * }
  */
 class ServerGetVersionResult implements HasToJson {
   /**
    * The version number of the analysis server.
    */
   final String version;
 
   ServerGetVersionResult(this.version);
 
   factory ServerGetVersionResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String version;
       if (json.containsKey("version")) {
         version = jsonDecoder._decodeString(jsonPath + ".version", json["version"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "version");
       }
       return new ServerGetVersionResult(version);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.getVersion result");
@@ skipping 39 matching lines @@
  */
 class ServerSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   final List<ServerService> subscriptions;
 
   ServerSetSubscriptionsParams(this.subscriptions);
 
   factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new ServerSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params");
@@ skipping 57 matching lines @@
 
   /**
    * The stack trace associated with the generation of the error, used for
    * debugging the server.
    */
   final String stackTrace;
 
   ServerErrorParams(this.fatal, this.message, this.stackTrace);
 
   factory ServerErrorParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       bool fatal;
       if (json.containsKey("fatal")) {
         fatal = jsonDecoder._decodeBool(jsonPath + ".fatal", json["fatal"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fatal");
       }
       String message;
       if (json.containsKey("message")) {
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
@@ skipping 58 matching lines @@
 class ServerStatusParams implements HasToJson {
   /**
    * The current status of analysis, including whether analysis is being
    * performed and if so what is being analyzed.
    */
   final AnalysisStatus analysis;
 
   ServerStatusParams({this.analysis});
 
   factory ServerStatusParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       AnalysisStatus analysis;
       if (json.containsKey("analysis")) {
         analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysis", json["analysis"]);
       }
       return new ServerStatusParams(analysis: analysis);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "server.status params");
     }
   }
@@ skipping 39 matching lines @@
  */
 class AnalysisGetErrorsParams implements HasToJson {
   /**
    * The file for which errors are being requested.
    */
   final String file;
 
   AnalysisGetErrorsParams(this.file);
 
   factory AnalysisGetErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new AnalysisGetErrorsParams(file);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors params");
@@ skipping 43 matching lines @@
  */
 class AnalysisGetErrorsResult implements HasToJson {
   /**
    * The errors associated with the file.
    */
   final List<AnalysisError> errors;
 
   AnalysisGetErrorsResult(this.errors);
 
   factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new AnalysisGetErrorsResult(errors);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result");
@@ skipping 45 matching lines @@
   final String file;
 
   /**
    * The offset for which hover information is being requested.
    */
   final int offset;
 
   AnalysisGetHoverParams(this.file, this.offset);
 
   factory AnalysisGetHoverParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 56 matching lines @@
    * if no information could be determined for the location. The list can
    * contain multiple items if the file is being analyzed in multiple contexts
    * in conflicting ways (such as a part that is included in multiple
    * libraries).
    */
   final List<HoverInformation> hovers;
 
   AnalysisGetHoverResult(this.hovers);
 
   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");
       }
       return new AnalysisGetHoverResult(hovers);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result");
@@ skipping 46 matching lines @@
 
   /**
    * A list of the files and directories within the included directories that
    * should not be analyzed.
    */
   final List<String> excluded;
 
   AnalysisSetAnalysisRootsParams(this.included, this.excluded);
 
   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");
       }
       List<String> excluded;
       if (json.containsKey("excluded")) {
         excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder._decodeString);
@@ skipping 52 matching lines @@
  */
 class AnalysisSetPriorityFilesParams implements HasToJson {
   /**
    * The files that are to be a priority for analysis.
    */
   final List<String> files;
 
   AnalysisSetPriorityFilesParams(this.files);
 
   factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new AnalysisSetPriorityFilesParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params");
@@ skipping 44 matching lines @@
 class AnalysisSetSubscriptionsParams implements HasToJson {
   /**
    * A table mapping services to a list of the files being subscribed to the
    * service.
    */
   final Map<AnalysisService, List<String>> subscriptions;
 
   AnalysisSetSubscriptionsParams(this.subscriptions);
 
   factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       Map<AnalysisService, List<String>> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeMap(jsonPath + ".subscriptions", json["subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisService.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new AnalysisSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params");
@@ skipping 44 matching lines @@
 class AnalysisUpdateContentParams implements HasToJson {
   /**
    * A table mapping the files whose content has changed to a description of
    * the content change.
    */
   final Map<String, dynamic> files;
 
   AnalysisUpdateContentParams(this.files);
 
   factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       Map<String, dynamic> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeMap(jsonPath + ".files", json["files"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeUnion(jsonPath, json, "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJson(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String jsonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath, json)}));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisUpdateContentParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params");
@@ skipping 43 matching lines @@
  */
 class AnalysisUpdateOptionsParams implements HasToJson {
   /**
    * The options that are to be used to control analysis.
    */
   final AnalysisOptions options;
 
   AnalysisUpdateOptionsParams(this.options);
 
   factory AnalysisUpdateOptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       AnalysisOptions options;
       if (json.containsKey("options")) {
         options = new AnalysisOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "options");
       }
       return new AnalysisUpdateOptionsParams(options);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.updateOptions params");
@@ skipping 49 matching lines @@
   final String file;
 
   /**
    * The errors contained in the file.
    */
   final List<AnalysisError> errors;
 
   AnalysisErrorsParams(this.file, this.errors);
 
   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));
@@ skipping 48 matching lines @@
  */
 class AnalysisFlushResultsParams implements HasToJson {
   /**
    * The files that are no longer being analyzed.
    */
   final List<String> files;
 
   AnalysisFlushResultsParams(this.files);
 
   factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new AnalysisFlushResultsParams(files);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params");
@@ skipping 45 matching lines @@
   final String file;
 
   /**
    * The folding regions contained in the file.
    */
   final List<FoldingRegion> regions;
 
   AnalysisFoldingParams(this.file, this.regions);
 
   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));
@@ skipping 58 matching lines @@
    * 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.
    */
   final List<HighlightRegion> regions;
 
   AnalysisHighlightsParams(this.file, this.regions);
 
   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));
@@ skipping 59 matching lines @@
    * 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.
    */
   final List<NavigationRegion> regions;
 
   AnalysisNavigationParams(this.file, this.regions);
 
   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));
@@ skipping 54 matching lines @@
   final String file;
 
   /**
    * The occurrences of references to elements within the file.
    */
   final List<Occurrences> occurrences;
 
   AnalysisOccurrencesParams(this.file, this.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));
@@ skipping 54 matching lines @@
   final String file;
 
   /**
    * The outline associated with the file.
    */
   final Outline outline;
 
   AnalysisOutlineParams(this.file, this.outline);
 
   factory AnalysisOutlineParams.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");
       }
       Outline outline;
       if (json.containsKey("outline")) {
         outline = new Outline.fromJson(jsonDecoder, jsonPath + ".outline", json["outline"]);
@@ skipping 54 matching lines @@
   final String file;
 
   /**
    * The overrides associated with the file.
    */
   final List<Override> overrides;
 
   AnalysisOverridesParams(this.file, this.overrides);
 
   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));
@@ skipping 54 matching lines @@
   final String file;
 
   /**
    * The offset within the file at which suggestions are to be made.
    */
   final int offset;
 
   CompletionGetSuggestionsParams(this.file, this.offset);
 
   factory CompletionGetSuggestionsParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 52 matching lines @@
  */
 class CompletionGetSuggestionsResult implements HasToJson {
   /**
    * The identifier used to associate results with this completion request.
    */
   final String id;
 
   CompletionGetSuggestionsResult(this.id);
 
   factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new CompletionGetSuggestionsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result");
@@ skipping 73 matching lines @@
 
   /**
    * True if this is that last set of results that will be returned for the
    * indicated completion.
    */
   final bool last;
 
   CompletionResultsParams(this.id, this.replacementOffset, this.replacementLength, this.results, this.last);
 
   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"]);
@@ skipping 89 matching lines @@
   final int offset;
 
   /**
    * True if potential matches are to be included in the results.
    */
   final bool includePotential;
 
   SearchFindElementReferencesParams(this.file, this.offset, this.includePotential);
 
   factory SearchFindElementReferencesParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 68 matching lines @@
 
   /**
    * The element referenced or defined at the given offset and whose references
    * will be returned in the search results.
    */
   final Element element;
 
   SearchFindElementReferencesResult(this.id, this.element);
 
   factory SearchFindElementReferencesResult.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");
       }
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
@@ skipping 48 matching lines @@
  */
 class SearchFindMemberDeclarationsParams implements HasToJson {
   /**
    * The name of the declarations to be found.
    */
   final String name;
 
   SearchFindMemberDeclarationsParams(this.name);
 
   factory SearchFindMemberDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       return new SearchFindMemberDeclarationsParams(name);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations params");
@@ skipping 43 matching lines @@
  */
 class SearchFindMemberDeclarationsResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindMemberDeclarationsResult(this.id);
 
   factory SearchFindMemberDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new SearchFindMemberDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result");
@@ skipping 39 matching lines @@
  */
 class SearchFindMemberReferencesParams implements HasToJson {
   /**
    * The name of the references to be found.
    */
   final String name;
 
   SearchFindMemberReferencesParams(this.name);
 
   factory SearchFindMemberReferencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       return new SearchFindMemberReferencesParams(name);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences params");
@@ skipping 43 matching lines @@
  */
 class SearchFindMemberReferencesResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindMemberReferencesResult(this.id);
 
   factory SearchFindMemberReferencesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new SearchFindMemberReferencesResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result");
@@ skipping 40 matching lines @@
 class SearchFindTopLevelDeclarationsParams implements HasToJson {
   /**
    * The regular expression used to match the names of the declarations to be
    * found.
    */
   final String pattern;
 
   SearchFindTopLevelDeclarationsParams(this.pattern);
 
   factory SearchFindTopLevelDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String pattern;
       if (json.containsKey("pattern")) {
         pattern = jsonDecoder._decodeString(jsonPath + ".pattern", json["pattern"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "pattern");
       }
       return new SearchFindTopLevelDeclarationsParams(pattern);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations params");
@@ skipping 43 matching lines @@
  */
 class SearchFindTopLevelDeclarationsResult implements HasToJson {
   /**
    * The identifier used to associate results with this search request.
    */
   final String id;
 
   SearchFindTopLevelDeclarationsResult(this.id);
 
   factory SearchFindTopLevelDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new SearchFindTopLevelDeclarationsResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations result");
@@ skipping 46 matching lines @@
   final String file;
 
   /**
    * The offset of the name of the type within the file.
    */
   final int offset;
 
   SearchGetTypeHierarchyParams(this.file, this.offset);
 
   factory SearchGetTypeHierarchyParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 60 matching lines @@
    *
    * 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.
    */
   final List<TypeHierarchyItem> hierarchyItems;
 
   SearchGetTypeHierarchyResult({this.hierarchyItems});
 
   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));
       }
       return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result");
     }
   }
@@ skipping 52 matching lines @@
 
   /**
    * True if this is that last set of results that will be returned for the
    * indicated search.
    */
   final bool last;
 
   SearchResultsParams(this.id, this.results, this.last);
 
   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));
@@ skipping 69 matching lines @@
   final int offset;
 
   /**
    * The length of the code for which assists are being requested.
    */
   final int length;
 
   EditGetAssistsParams(this.file, this.offset, this.length);
 
   factory EditGetAssistsParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 61 matching lines @@
  */
 class EditGetAssistsResult implements HasToJson {
   /**
    * The assists that are available at the given location.
    */
   final List<SourceChange> assists;
 
   EditGetAssistsResult(this.assists);
 
   factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new EditGetAssistsResult(assists);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result");
@@ skipping 51 matching lines @@
   final int offset;
 
   /**
    * The length of the code on which the refactoring would be based.
    */
   final int length;
 
   EditGetAvailableRefactoringsParams(this.file, this.offset, this.length);
 
   factory EditGetAvailableRefactoringsParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 61 matching lines @@
  */
 class EditGetAvailableRefactoringsResult implements HasToJson {
   /**
    * The kinds of refactorings that are valid for the given selection.
    */
   final List<RefactoringKind> kinds;
 
   EditGetAvailableRefactoringsResult(this.kinds);
 
   factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new EditGetAvailableRefactoringsResult(kinds);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result");
@@ skipping 45 matching lines @@
   final String file;
 
   /**
    * The offset used to select the errors for which fixes will be returned.
    */
   final int offset;
 
   EditGetFixesParams(this.file, this.offset);
 
   factory EditGetFixesParams.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 57 matching lines @@
    * the lists of changes in the response. In particular, it is always the case
    * that errors.length == fixes.length and that fixes[i] is the list of fixes
    * for the error in errors[i]. The list of changes corresponding to an error
    * can be empty if there are no fixes available for that error.
    */
   final List<ErrorFixes> fixes;
 
   EditGetFixesResult(this.fixes);
 
   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");
       }
       return new EditGetFixesResult(fixes);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
@@ skipping 74 matching lines @@
    * data is dependent on the kind of refactoring being performed. The data
    * that is expected is documented in the section titled Refactorings, labeled
    * as “Options”. This field can be omitted if the refactoring does not
    * require any options or if the values of those options are not known.
    */
   final Object options;
 
   EditGetRefactoringParams(this.kindId, this.file, this.offset, this.length, this.validateOnly, {this.options});
 
   factory EditGetRefactoringParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       RefactoringKind kindId;
       if (json.containsKey("kindId")) {
         kindId = new RefactoringKind.fromJson(jsonDecoder, jsonPath + ".kindId", json["kindId"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kindId");
       }
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
@@ skipping 118 matching lines @@
    * 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.
    */
   final List<String> potentialEdits;
 
   EditGetRefactoringResult(this.status, {this.feedback, this.change, this.potentialEdits});
 
   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");
       }
       Object feedback;
       if (json.containsKey("feedback")) {
         feedback = json["feedback"];
@@ skipping 66 matching lines @@
  */
 class DebugCreateContextParams implements HasToJson {
   /**
    * The path of the Dart or HTML file that will be launched.
    */
   final String contextRoot;
 
   DebugCreateContextParams(this.contextRoot);
 
   factory DebugCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String contextRoot;
       if (json.containsKey("contextRoot")) {
         contextRoot = jsonDecoder._decodeString(jsonPath + ".contextRoot", json["contextRoot"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "contextRoot");
       }
       return new DebugCreateContextParams(contextRoot);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.createContext params");
@@ skipping 43 matching lines @@
  */
 class DebugCreateContextResult implements HasToJson {
   /**
    * The identifier used to refer to the debugging context that was created.
    */
   final String id;
 
   DebugCreateContextResult(this.id);
 
   factory DebugCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new DebugCreateContextResult(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.createContext result");
@@ skipping 39 matching lines @@
  */
 class DebugDeleteContextParams implements HasToJson {
   /**
    * The identifier of the debugging context that is to be deleted.
    */
   final String id;
 
   DebugDeleteContextParams(this.id);
 
   factory DebugDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new DebugDeleteContextParams(id);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.deleteContext params");
@@ skipping 55 matching lines @@
   final String file;
 
   /**
    * The URI to be mapped into a file path.
    */
   final String uri;
 
   DebugMapUriParams(this.id, {this.file, this.uri});
 
   factory DebugMapUriParams.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");
       }
       String file;
       if (json.containsKey("file")) {
         file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
@@ skipping 69 matching lines @@
 
   /**
    * The URI to which the file path was mapped. This field is omitted if the
    * file field was not given in the request.
    */
   final String uri;
 
   DebugMapUriResult({this.file, this.uri});
 
   factory DebugMapUriResult.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"]);
       }
       String uri;
       if (json.containsKey("uri")) {
         uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
       }
       return new DebugMapUriResult(file: file, uri: uri);
@@ skipping 48 matching lines @@
  */
 class DebugSetSubscriptionsParams implements HasToJson {
   /**
    * A list of the services being subscribed to.
    */
   final List<DebugService> subscriptions;
 
   DebugSetSubscriptionsParams(this.subscriptions);
 
   factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
       return new DebugSetSubscriptionsParams(subscriptions);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "debug.setSubscriptions params");
@@ skipping 58 matching lines @@
 
   /**
    * A mapping from the paths of HTML files that reference Dart files to a list
    * of the Dart files they reference.
    */
   final Map<String, List<String>> htmlToDart;
 
   DebugLaunchDataParams(this.executables, this.dartToHtml, this.htmlToDart);
 
   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");
       }
       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));
@@ skipping 58 matching lines @@
  */
 class AddContentOverlay implements HasToJson {
   /**
    * The new content of the file.
    */
   final String content;
 
   AddContentOverlay(this.content);
 
   factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       if (json["type"] != "add") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "add");
       }
       String content;
       if (json.containsKey("content")) {
         content = jsonDecoder._decodeString(jsonPath + ".content", json["content"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "content");
       }
@@ skipping 66 matching lines @@
   /**
    * The correction message to be displayed for this error. The correction
    * message should indicate how the user can fix the error. The field is
    * omitted if there is no correction message associated with the error code.
    */
   final String correction;
 
   AnalysisError(this.severity, this.type, this.location, this.message, {this.correction});
 
   factory AnalysisError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       ErrorSeverity severity;
       if (json.containsKey("severity")) {
         severity = new ErrorSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "severity");
       }
       ErrorType type;
       if (json.containsKey("type")) {
         type = new ErrorType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
@@ skipping 97 matching lines @@
 
   /**
    * True is hints should be generated as part of generating errors and
    * warnings.
    */
   final bool generateHints;
 
   AnalysisOptions({this.enableAsync, this.enableDeferredLoading, this.enableEnums, this.generateDart2jsHints, this.generateHints});
 
   factory AnalysisOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       bool enableAsync;
       if (json.containsKey("enableAsync")) {
         enableAsync = jsonDecoder._decodeBool(jsonPath + ".enableAsync", json["enableAsync"]);
       }
       bool enableDeferredLoading;
       if (json.containsKey("enableDeferredLoading")) {
         enableDeferredLoading = jsonDecoder._decodeBool(jsonPath + ".enableDeferredLoading", json["enableDeferredLoading"]);
       }
       bool enableEnums;
@@ skipping 141 matching lines @@
 
   /**
    * The name of the current target of analysis. This field is omitted if
    * analyzing is false.
    */
   final String analysisTarget;
 
   AnalysisStatus(this.analyzing, {this.analysisTarget});
 
   factory AnalysisStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       bool analyzing;
       if (json.containsKey("analyzing")) {
         analyzing = jsonDecoder._decodeBool(jsonPath + ".analyzing", json["analyzing"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "analyzing");
       }
       String analysisTarget;
       if (json.containsKey("analysisTarget")) {
         analysisTarget = jsonDecoder._decodeString(jsonPath + ".analysisTarget", json["analysisTarget"]);
@@ skipping 44 matching lines @@
  */
 class ChangeContentOverlay implements HasToJson {
   /**
    * The edits to be applied to the file.
    */
   final List<SourceEdit> edits;
 
   ChangeContentOverlay(this.edits);
 
   factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == 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");
       }
@@ skipping 203 matching lines @@
 
   /**
    * The type of the options parameter being suggested. This field is omitted
    * if the parameterName field is omitted.
    */
   final 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});
 
   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 {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       CompletionRelevance relevance;
       if (json.containsKey("relevance")) {
         relevance = new CompletionRelevance.fromJson(jsonDecoder, jsonPath + ".relevance", json["relevance"]);
@@ skipping 394 matching lines @@
   /**
    * The return type of the element. If the element is not a method or function
    * this field will not be defined. If the element does not have a declared
    * return type, this field will contain an empty string.
    */
   final String returnType;
 
   Element(this.kind, this.name, this.flags, {this.location, this.parameters, this.returnType});
 
   factory Element.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       ElementKind kind;
       if (json.containsKey("kind")) {
         kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
@@ skipping 216 matching lines @@
 
   /**
    * Additional data related to the error. This field is omitted if there is no
    * additional data available.
    */
   final Object data;
 
   Error(this.code, this.message, {this.data});
 
   factory Error.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String code;
       if (json.containsKey("code")) {
         code = jsonDecoder._decodeString(jsonPath + ".code", json["code"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "code");
       }
       String message;
       if (json.containsKey("message")) {
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
@@ skipping 58 matching lines @@
   final AnalysisError error;
 
   /**
    * The fixes associated with the error.
    */
   final List<SourceChange> fixes;
 
   ErrorFixes(this.error, this.fixes);
 
   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));
@@ skipping 162 matching lines @@
   final String file;
 
   /**
    * The offset of the region to be highlighted.
    */
   final ExecutableKind offset;
 
   ExecutableFile(this.file, this.offset);
 
   factory ExecutableFile.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");
       }
       ExecutableKind offset;
       if (json.containsKey("offset")) {
         offset = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".offset", json["offset"]);
@@ skipping 163 matching lines @@
   final int offset;
 
   /**
    * The length of the region to be folded.
    */
   final int length;
 
   FoldingRegion(this.kind, this.offset, this.length);
 
   factory FoldingRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       FoldingKind kind;
       if (json.containsKey("kind")) {
         kind = new FoldingKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 64 matching lines @@
   final int offset;
 
   /**
    * The length of the region to be highlighted.
    */
   final int length;
 
   HighlightRegion(this.type, this.offset, this.length);
 
   factory HighlightRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       HighlightRegionType type;
       if (json.containsKey("type")) {
         type = new HighlightRegionType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "type");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 331 matching lines @@
 
   /**
    * The name of the static type of the expression. This data is omitted if the
    * location does not correspond to an expression.
    */
   final String staticType;
 
   HoverInformation(this.offset, this.length, {this.containingLibraryPath, this.containingLibraryName, this.dartdoc, this.elementDescription, this.elementKind, this.parameter, this.propagatedType, this.staticType});
 
   factory HoverInformation.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"]);
@@ skipping 128 matching lines @@
 
   /**
    * Pre-computed suggestions for what every region might want to be changed
    * to.
    */
   final List<LinkedEditSuggestion> suggestions;
 
   LinkedEditGroup(this.positions, this.length, this.suggestions);
 
   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");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
@@ skipping 58 matching lines @@
   final String value;
 
   /**
    * The kind of value being proposed.
    */
   final LinkedEditSuggestionKind kind;
 
   LinkedEditSuggestion(this.value, this.kind);
 
   factory LinkedEditSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String value;
       if (json.containsKey("value")) {
         value = jsonDecoder._decodeString(jsonPath + ".value", json["value"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "value");
       }
       LinkedEditSuggestionKind kind;
       if (json.containsKey("kind")) {
         kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
@@ skipping 123 matching lines @@
 
   /**
    * The one-based index of the column containing the first character of the
    * range.
    */
   final int startColumn;
 
   Location(this.file, this.offset, this.length, this.startLine, this.startColumn);
 
   factory Location.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 83 matching lines @@
 
   /**
    * The elements to which the given region is bound. By opening the
    * declaration of the elements, clients can implement one form of navigation.
    */
   final List<Element> targets;
 
   NavigationRegion(this.offset, this.length, this.targets);
 
   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"]);
@@ skipping 64 matching lines @@
   final List<int> offsets;
 
   /**
    * The length of the name of the referenced element.
    */
   final int length;
 
   Occurrences(this.element, this.offsets, this.length);
 
   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);
@@ skipping 74 matching lines @@
 
   /**
    * The children of the node. The field will be omitted if the node has no
    * children.
    */
   final List<Outline> children;
 
   Outline(this.element, this.offset, this.length, {this.children});
 
   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"]);
@@ skipping 83 matching lines @@
   /**
    * 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.
    */
   final List<OverriddenMember> interfaceMembers;
 
   Override(this.offset, this.length, {this.superclassMember, this.interfaceMembers});
 
   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"]);
@@ skipping 67 matching lines @@
   final Element element;
 
   /**
    * The name of the class in which the member is defined.
    */
   final String className;
 
   OverriddenMember(this.element, this.className);
 
   factory OverriddenMember.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");
       }
       String className;
       if (json.containsKey("className")) {
         className = jsonDecoder._decodeString(jsonPath + ".className", json["className"]);
@@ skipping 49 matching lines @@
   final String file;
 
   /**
    * The offset of the position.
    */
   final int offset;
 
   Position(this.file, this.offset);
 
   factory Position.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");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
@@ skipping 140 matching lines @@
   /**
    * The parameter list of the parameter's function type. If the parameter is
    * not of a function type, this field will not be defined. If the function
    * type has zero parameters, this field will have a value of "()".
    */
   final String parameters;
 
   RefactoringMethodParameter(this.kind, this.type, this.name, {this.id, this.parameters});
 
   factory RefactoringMethodParameter.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"]);
       }
       RefactoringMethodParameterKind kind;
       if (json.containsKey("kind")) {
         kind = new RefactoringMethodParameterKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
@@ skipping 131 matching lines @@
   final String message;
 
   /**
    * The location of the problem being represented.
    */
   final Location location;
 
   RefactoringProblem(this.severity, this.message, this.location);
 
   factory RefactoringProblem.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       RefactoringProblemSeverity severity;
       if (json.containsKey("severity")) {
         severity = new RefactoringProblemSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "severity");
       }
       String message;
       if (json.containsKey("message")) {
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
@@ skipping 101 matching lines @@
  * RemoveContentOverlay
  *
  * {
  *   "type": "remove"
  * }
  */
 class RemoveContentOverlay implements HasToJson {
   RemoveContentOverlay();
 
   factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       if (json["type"] != "remove") {
         throw jsonDecoder.mismatch(jsonPath, "equal " + "remove");
       }
       return new RemoveContentOverlay();
     } else {
       throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay");
     }
   }
 
@@ skipping 54 matching lines @@
 
   /**
    * The elements that contain the result, starting with the most immediately
    * enclosing ancestor and ending with the library.
    */
   final List<Element> path;
 
   SearchResult(this.location, this.kind, this.isPotential, this.path);
 
   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"]);
@@ skipping 202 matching lines @@
   final List<LinkedEditGroup> linkedEditGroups;
 
   /**
    * The position that should be selected after the edits have been applied.
    */
   final Position selection;
 
   SourceChange(this.message, this.edits, this.linkedEditGroups, {this.selection});
 
   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));
@@ skipping 86 matching lines @@
    * For example, some refactoring operations can produce edits that might not
    * be appropriate (referred to as potential edits). Such edits will have an
    * id so that they can be referenced. Edits in the same response that do not
    * need to be referenced will not have an id.
    */
   final String id;
 
   SourceEdit(this.offset, this.length, this.replacement, {this.id});
 
   factory SourceEdit.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"]);
@@ skipping 67 matching lines @@
   final String file;
 
   /**
    * A list of the edits used to effect the change.
    */
   final List<SourceEdit> edits;
 
   SourceFileEdit(this.file, this.edits);
 
   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));
@@ skipping 90 matching lines @@
   /**
    * 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.
    */
   final List<int> subclasses;
 
   TypeHierarchyItem(this.classElement, this.interfaces, this.mixins, this.subclasses, {this.displayName, this.memberElement, this.superclass});
 
   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"]);
@@ skipping 104 matching lines @@
    * 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].
    */
   final List<int> lengths;
 
   ExtractLocalVariableFeedback(this.names, this.offsets, this.lengths);
 
   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");
       }
       List<int> offsets;
       if (json.containsKey("offsets")) {
         offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
@@ skipping 66 matching lines @@
    * True if all occurrences of the expression within the scope in which the
    * variable will be defined should be replaced by a reference to the local
    * variable. The expression used to initiate the refactoring will always be
    * replaced.
    */
   final bool extractAll;
 
   ExtractLocalVariableOptions(this.name, this.extractAll);
 
   factory ExtractLocalVariableOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String name;
       if (json.containsKey("name")) {
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
         extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
@@ skipping 102 matching lines @@
    * 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].
    */
   final List<int> lengths;
 
   ExtractMethodFeedback(this.offset, this.length, this.returnType, this.names, this.canCreateGetter, this.parameters, this.occurrences, this.offsets, this.lengths);
 
   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"]);
@@ skipping 147 matching lines @@
   /**
    * 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.
    */
   final bool extractAll;
 
   ExtractMethodOptions(this.returnType, this.createGetter, this.name, this.parameters, this.extractAll);
 
   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"]);
@@ skipping 83 matching lines @@
 
   /**
    * True if all invocations of the method should be inlined, or false if only
    * the invocation site used to create this refactoring should be inlined.
    */
   final bool inlineAll;
 
   InlineMethodOptions(this.deleteSource, this.inlineAll);
 
   factory InlineMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       bool deleteSource;
       if (json.containsKey("deleteSource")) {
         deleteSource = jsonDecoder._decodeBool(jsonPath + ".deleteSource", json["deleteSource"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "deleteSource");
       }
       bool inlineAll;
       if (json.containsKey("inlineAll")) {
         inlineAll = jsonDecoder._decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
@@ skipping 54 matching lines @@
   final int offset;
 
   /**
    * The length of the name selected to be renamed.
    */
   final int length;
 
   RenameFeedback(this.offset, this.length);
 
   factory RenameFeedback.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"]);
@@ skipping 48 matching lines @@
  */
 class RenameOptions implements HasToJson {
   /**
    * The name that the element should have after the refactoring.
    */
   final String newName;
 
   RenameOptions(this.newName);
 
   factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
+    if (json == null) {
+      json = {};
+    }
     if (json is Map) {
       String newName;
       if (json.containsKey("newName")) {
         newName = jsonDecoder._decodeString(jsonPath + ".newName", json["newName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "newName");
       }
       return new RenameOptions(newName);
     } else {
       throw jsonDecoder.mismatch(jsonPath, "rename options");
@@ skipping 22 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }