Improve error messages for invalid requests

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/tool/spec/generate_files".
 
 part of protocol;
 /**
@@ skipping 51 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "server.getVersion result", json);
     }
   }
 
   factory ServerGetVersionResult.fromResponse(Response response) {
     return new ServerGetVersionResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 99 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params", json);
     }
   }
 
   factory ServerSetSubscriptionsParams.fromRequest(Request request) {
     return new ServerSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 78 matching lines @@
     }
     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 ServerConnectedParams(version);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "server.connected params");
+      throw jsonDecoder.mismatch(jsonPath, "server.connected params", json);
     }
   }
 
   factory ServerConnectedParams.fromNotification(Notification notification) {
     return new ServerConnectedParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 107 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
         stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "stackTrace");
       }
       return new ServerErrorParams(isFatal, message, stackTrace);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "server.error params");
+      throw jsonDecoder.mismatch(jsonPath, "server.error params", json);
     }
   }
 
   factory ServerErrorParams.fromNotification(Notification notification) {
     return new ServerErrorParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 84 matching lines @@
       AnalysisStatus analysis;
       if (json.containsKey("analysis")) {
         analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysis", json["analysis"]);
       }
       PubStatus pub;
       if (json.containsKey("pub")) {
         pub = new PubStatus.fromJson(jsonDecoder, jsonPath + ".pub", json["pub"]);
       }
       return new ServerStatusParams(analysis: analysis, pub: pub);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "server.status params");
+      throw jsonDecoder.mismatch(jsonPath, "server.status params", json);
     }
   }
 
   factory ServerStatusParams.fromNotification(Notification notification) {
     return new ServerStatusParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 64 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors params", json);
     }
   }
 
   factory AnalysisGetErrorsParams.fromRequest(Request request) {
     return new AnalysisGetErrorsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result", json);
     }
   }
 
   factory AnalysisGetErrorsResult.fromResponse(Response response) {
     return new AnalysisGetErrorsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new AnalysisGetHoverParams(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params", json);
     }
   }
 
   factory AnalysisGetHoverParams.fromRequest(Request request) {
     return new AnalysisGetHoverParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 68 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result", json);
     }
   }
 
   factory AnalysisGetHoverResult.fromResponse(Response response) {
     return new AnalysisGetHoverResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 105 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "libraries");
       }
       Map<String, Map<String, List<String>>> packageMap;
       if (json.containsKey("packageMap")) {
         packageMap = jsonDecoder._decodeMap(jsonPath + ".packageMap", json["packageMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeMap(jsonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString)));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "packageMap");
       }
       return new AnalysisGetLibraryDependenciesResult(libraries, packageMap);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies result");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies result", json);
     }
   }
 
   factory AnalysisGetLibraryDependenciesResult.fromResponse(Response response) {
     return new AnalysisGetLibraryDependenciesResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 110 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new AnalysisGetNavigationParams(file, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation params", json);
     }
   }
 
   factory AnalysisGetNavigationParams.fromRequest(Request request) {
     return new AnalysisGetNavigationParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 113 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       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");
       }
       return new AnalysisGetNavigationResult(files, targets, regions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result", json);
     }
   }
 
   factory AnalysisGetNavigationResult.fromResponse(Response response) {
     return new AnalysisGetNavigationResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 60 matching lines @@
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       List<String> roots;
       if (json.containsKey("roots")) {
         roots = jsonDecoder._decodeList(jsonPath + ".roots", json["roots"], jsonDecoder._decodeString);
       }
       return new AnalysisReanalyzeParams(roots: roots);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json);
     }
   }
 
   factory AnalysisReanalyzeParams.fromRequest(Request request) {
     return new AnalysisReanalyzeParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 147 matching lines @@
         excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder._decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "excluded");
       }
       Map<String, String> packageRoots;
       if (json.containsKey("packageRoots")) {
         packageRoots = jsonDecoder._decodeMap(jsonPath + ".packageRoots", json["packageRoots"], valueDecoder: jsonDecoder._decodeString);
       }
       return new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots: packageRoots);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params", json);
     }
   }
 
   factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
     return new AnalysisSetAnalysisRootsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 86 matching lines @@
     }
     if (json is Map) {
       List<GeneralAnalysisService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new AnalysisSetGeneralSubscriptionsParams(subscriptions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions params", json);
     }
   }
 
   factory AnalysisSetGeneralSubscriptionsParams.fromRequest(Request request) {
     return new AnalysisSetGeneralSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 78 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params", json);
     }
   }
 
   factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
     return new AnalysisSetPriorityFilesParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params", json);
     }
   }
 
   factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
     return new AnalysisSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params", json);
     }
   }
 
   factory AnalysisUpdateContentParams.fromRequest(Request request) {
     return new AnalysisUpdateContentParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 33 matching lines @@
 class AnalysisUpdateContentResult implements HasToJson {
   AnalysisUpdateContentResult();
 
   factory AnalysisUpdateContentResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json == null) {
       json = {};
     }
     if (json is Map) {
       return new AnalysisUpdateContentResult();
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent result");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent result", json);
     }
   }
 
   factory AnalysisUpdateContentResult.fromResponse(Response response) {
     return new AnalysisUpdateContentResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 55 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.updateOptions params", json);
     }
   }
 
   factory AnalysisUpdateOptionsParams.fromRequest(Request request) {
     return new AnalysisUpdateOptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 78 matching lines @@
     }
     if (json is Map) {
       List<String> directories;
       if (json.containsKey("directories")) {
         directories = jsonDecoder._decodeList(jsonPath + ".directories", json["directories"], jsonDecoder._decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "directories");
       }
       return new AnalysisAnalyzedFilesParams(directories);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params", json);
     }
   }
 
   factory AnalysisAnalyzedFilesParams.fromNotification(Notification notification) {
     return new AnalysisAnalyzedFilesParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
         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");
       }
       return new AnalysisErrorsParams(file, errors);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.errors params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json);
     }
   }
 
   factory AnalysisErrorsParams.fromNotification(Notification notification) {
     return new AnalysisErrorsParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 60 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params", json);
     }
   }
 
   factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
     return new AnalysisFlushResultsParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
         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");
       }
       return new AnalysisFoldingParams(file, regions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.folding params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json);
     }
   }
 
   factory AnalysisFoldingParams.fromNotification(Notification notification) {
     return new AnalysisFoldingParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 91 matching lines @@
         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");
       }
       return new AnalysisHighlightsParams(file, regions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json);
     }
   }
 
   factory AnalysisHighlightsParams.fromNotification(Notification notification) {
     return new AnalysisHighlightsParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 133 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       int delta;
       if (json.containsKey("delta")) {
         delta = jsonDecoder._decodeInt(jsonPath + ".delta", json["delta"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "delta");
       }
       return new AnalysisInvalidateParams(file, offset, length, delta);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.invalidate params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.invalidate params", json);
     }
   }
 
   factory AnalysisInvalidateParams.fromNotification(Notification notification) {
     return new AnalysisInvalidateParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 151 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       List<String> files;
       if (json.containsKey("files")) {
         files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "files");
       }
       return new AnalysisNavigationParams(file, regions, targets, files);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json);
     }
   }
 
   factory AnalysisNavigationParams.fromNotification(Notification notification) {
     return new AnalysisNavigationParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 89 matching lines @@
         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");
       }
       return new AnalysisOccurrencesParams(file, occurrences);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json);
     }
   }
 
   factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
     return new AnalysisOccurrencesParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 83 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       Outline outline;
       if (json.containsKey("outline")) {
         outline = new Outline.fromJson(jsonDecoder, jsonPath + ".outline", json["outline"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "outline");
       }
       return new AnalysisOutlineParams(file, outline);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.outline params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.outline params", json);
     }
   }
 
   factory AnalysisOutlineParams.fromNotification(Notification notification) {
     return new AnalysisOutlineParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 83 matching lines @@
         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");
       }
       return new AnalysisOverridesParams(file, overrides);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params");
+      throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params", json);
     }
   }
 
   factory AnalysisOverridesParams.fromNotification(Notification notification) {
     return new AnalysisOverridesParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 83 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new CompletionGetSuggestionsParams(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params");
+      throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params", json);
     }
   }
 
   factory CompletionGetSuggestionsParams.fromRequest(Request request) {
     return new CompletionGetSuggestionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 60 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result", json);
     }
   }
 
   factory CompletionGetSuggestionsResult.fromResponse(Response response) {
     return new CompletionGetSuggestionsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 169 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "results");
       }
       bool isLast;
       if (json.containsKey("isLast")) {
         isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new CompletionResultsParams(id, replacementOffset, replacementLength, results, isLast);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "completion.results params");
+      throw jsonDecoder.mismatch(jsonPath, "completion.results params", json);
     }
   }
 
   factory CompletionResultsParams.fromNotification(Notification notification) {
     return new CompletionResultsParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 119 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       bool includePotential;
       if (json.containsKey("includePotential")) {
         includePotential = jsonDecoder._decodeBool(jsonPath + ".includePotential", json["includePotential"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "includePotential");
       }
       return new SearchFindElementReferencesParams(file, offset, includePotential);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params");
+      throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params", json);
     }
   }
 
   factory SearchFindElementReferencesParams.fromRequest(Request request) {
     return new SearchFindElementReferencesParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 92 matching lines @@
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       }
       Element element;
       if (json.containsKey("element")) {
         element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
       }
       return new SearchFindElementReferencesResult(id: id, element: element);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result");
+      throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result", json);
     }
   }
 
   factory SearchFindElementReferencesResult.fromResponse(Response response) {
     return new SearchFindElementReferencesResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 64 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations params", json);
     }
   }
 
   factory SearchFindMemberDeclarationsParams.fromRequest(Request request) {
     return new SearchFindMemberDeclarationsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result", json);
     }
   }
 
   factory SearchFindMemberDeclarationsResult.fromResponse(Response response) {
     return new SearchFindMemberDeclarationsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences params", json);
     }
   }
 
   factory SearchFindMemberReferencesParams.fromRequest(Request request) {
     return new SearchFindMemberReferencesParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result", json);
     }
   }
 
   factory SearchFindMemberReferencesResult.fromResponse(Response response) {
     return new SearchFindMemberReferencesResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 59 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations params", json);
     }
   }
 
   factory SearchFindTopLevelDeclarationsParams.fromRequest(Request request) {
     return new SearchFindTopLevelDeclarationsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations result", json);
     }
   }
 
   factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) {
     return new SearchFindTopLevelDeclarationsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 82 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new SearchGetTypeHierarchyParams(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params");
+      throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params", json);
     }
   }
 
   factory SearchGetTypeHierarchyParams.fromRequest(Request request) {
     return new SearchGetTypeHierarchyParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 73 matching lines @@
     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");
+      throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result", json);
     }
   }
 
   factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
     return new SearchGetTypeHierarchyResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 107 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "results");
       }
       bool isLast;
       if (json.containsKey("isLast")) {
         isLast = jsonDecoder._decodeBool(jsonPath + ".isLast", json["isLast"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isLast");
       }
       return new SearchResultsParams(id, results, isLast);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "search.results params");
+      throw jsonDecoder.mismatch(jsonPath, "search.results params", json);
     }
   }
 
   factory SearchResultsParams.fromNotification(Notification notification) {
     return new SearchResultsParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 129 matching lines @@
         selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionLength");
       }
       int lineLength;
       if (json.containsKey("lineLength")) {
         lineLength = jsonDecoder._decodeInt(jsonPath + ".lineLength", json["lineLength"]);
       }
       return new EditFormatParams(file, selectionOffset, selectionLength, lineLength: lineLength);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.format params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.format params", json);
     }
   }
 
   factory EditFormatParams.fromRequest(Request request) {
     return new EditFormatParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 116 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
       }
       int selectionLength;
       if (json.containsKey("selectionLength")) {
         selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "selectionLength");
       }
       return new EditFormatResult(edits, selectionOffset, selectionLength);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.format result");
+      throw jsonDecoder.mismatch(jsonPath, "edit.format result", json);
     }
   }
 
   factory EditFormatResult.fromResponse(Response response) {
     return new EditFormatResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 109 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAssistsParams(file, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params", json);
     }
   }
 
   factory EditGetAssistsParams.fromRequest(Request request) {
     return new EditGetAssistsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 63 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result", json);
     }
   }
 
   factory EditGetAssistsResult.fromResponse(Response response) {
     return new EditGetAssistsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 103 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new EditGetAvailableRefactoringsParams(file, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params", json);
     }
   }
 
   factory EditGetAvailableRefactoringsParams.fromRequest(Request request) {
     return new EditGetAvailableRefactoringsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 63 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result", json);
     }
   }
 
   factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
     return new EditGetAvailableRefactoringsResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 80 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new EditGetFixesParams(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params", json);
     }
   }
 
   factory EditGetFixesParams.fromRequest(Request request) {
     return new EditGetFixesParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 60 matching lines @@
     }
     if (json is Map) {
       List<AnalysisErrorFixes> fixes;
       if (json.containsKey("fixes")) {
         fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new EditGetFixesResult(fixes);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json);
     }
   }
 
   factory EditGetFixesResult.fromResponse(Response response) {
     return new EditGetFixesResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 179 matching lines @@
         validateOnly = jsonDecoder._decodeBool(jsonPath + ".validateOnly", json["validateOnly"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "validateOnly");
       }
       RefactoringOptions options;
       if (json.containsKey("options")) {
         options = new RefactoringOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"], kind);
       }
       return new EditGetRefactoringParams(kind, file, offset, length, validateOnly, options: options);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params", json);
     }
   }
 
   factory EditGetRefactoringParams.fromRequest(Request request) {
     var params = new EditGetRefactoringParams.fromJson(
         new RequestDecoder(request), "params", request._params);
     REQUEST_ID_REFACTORING_KINDS[request.id] = params.kind;
     return params;
   }
 
@@ skipping 216 matching lines @@
       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);
       }
       return new EditGetRefactoringResult(initialProblems, optionsProblems, finalProblems, feedback: feedback, change: change, potentialEdits: potentialEdits);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result");
+      throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json);
     }
   }
 
   factory EditGetRefactoringResult.fromResponse(Response response) {
     return new EditGetRefactoringResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 78 matching lines @@
     }
     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 EditSortMembersParams(file);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers params");
+      throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers params", json);
     }
   }
 
   factory EditSortMembersParams.fromRequest(Request request) {
     return new EditSortMembersParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 59 matching lines @@
     }
     if (json is Map) {
       SourceFileEdit edit;
       if (json.containsKey("edit")) {
         edit = new SourceFileEdit.fromJson(jsonDecoder, jsonPath + ".edit", json["edit"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edit");
       }
       return new EditSortMembersResult(edit);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers result");
+      throw jsonDecoder.mismatch(jsonPath, "edit.sortMembers result", json);
     }
   }
 
   factory EditSortMembersResult.fromResponse(Response response) {
     return new EditSortMembersResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 59 matching lines @@
     }
     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 ExecutionCreateContextParams(contextRoot);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.createContext params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.createContext params", json);
     }
   }
 
   factory ExecutionCreateContextParams.fromRequest(Request request) {
     return new ExecutionCreateContextParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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 ExecutionCreateContextResult(id);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.createContext result");
+      throw jsonDecoder.mismatch(jsonPath, "execution.createContext result", json);
     }
   }
 
   factory ExecutionCreateContextResult.fromResponse(Response response) {
     return new ExecutionCreateContextResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 57 matching lines @@
     }
     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 ExecutionDeleteContextParams(id);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.deleteContext params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.deleteContext params", json);
     }
   }
 
   factory ExecutionDeleteContextParams.fromRequest(Request request) {
     return new ExecutionDeleteContextParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 118 matching lines @@
       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 ExecutionMapUriParams(id, file: file, uri: uri);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri params", json);
     }
   }
 
   factory ExecutionMapUriParams.fromRequest(Request request) {
     return new ExecutionMapUriParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 88 matching lines @@
       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 ExecutionMapUriResult(file: file, uri: uri);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri result");
+      throw jsonDecoder.mismatch(jsonPath, "execution.mapUri result", json);
     }
   }
 
   factory ExecutionMapUriResult.fromResponse(Response response) {
     return new ExecutionMapUriResult.fromJson(
         new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), "result", response._result);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 64 matching lines @@
     }
     if (json is Map) {
       List<ExecutionService> subscriptions;
       if (json.containsKey("subscriptions")) {
         subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subscriptions");
       }
       return new ExecutionSetSubscriptionsParams(subscriptions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params", json);
     }
   }
 
   factory ExecutionSetSubscriptionsParams.fromRequest(Request request) {
     return new ExecutionSetSubscriptionsParams.fromJson(
         new RequestDecoder(request), "params", request._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 124 matching lines @@
       ExecutableKind kind;
       if (json.containsKey("kind")) {
         kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       }
       List<String> referencedFiles;
       if (json.containsKey("referencedFiles")) {
         referencedFiles = jsonDecoder._decodeList(jsonPath + ".referencedFiles", json["referencedFiles"], jsonDecoder._decodeString);
       }
       return new ExecutionLaunchDataParams(file, kind: kind, referencedFiles: referencedFiles);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "execution.launchData params");
+      throw jsonDecoder.mismatch(jsonPath, "execution.launchData params", json);
     }
   }
 
   factory ExecutionLaunchDataParams.fromNotification(Notification notification) {
     return new ExecutionLaunchDataParams.fromJson(
         new ResponseDecoder(null), "params", notification._params);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 61 matching lines @@
   AddContentOverlay(String content) {
     this.content = 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");
+        throw jsonDecoder.mismatch(jsonPath, "equal " + "add", json);
       }
       String content;
       if (json.containsKey("content")) {
         content = jsonDecoder._decodeString(jsonPath + ".content", json["content"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "content");
       }
       return new AddContentOverlay(content);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay");
+      throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "add";
     result["content"] = content;
     return result;
   }
 
@@ skipping 145 matching lines @@
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String correction;
       if (json.containsKey("correction")) {
         correction = jsonDecoder._decodeString(jsonPath + ".correction", json["correction"]);
       }
       return new AnalysisError(severity, type, location, message, correction: correction);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "AnalysisError");
+      throw jsonDecoder.mismatch(jsonPath, "AnalysisError", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["severity"] = severity.toJson();
     result["type"] = type.toJson();
     result["location"] = location.toJson();
     result["message"] = message;
     if (correction != null) {
@@ skipping 89 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "error");
       }
       List<SourceChange> fixes;
       if (json.containsKey("fixes")) {
         fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "fixes");
       }
       return new AnalysisErrorFixes(error, fixes: fixes);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes");
+      throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["error"] = error.toJson();
     result["fixes"] = fixes.map((SourceChange value) => value.toJson()).toList();
     return result;
   }
 
@@ skipping 56 matching lines @@
   }
 
   factory AnalysisErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisErrorSeverity(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorSeverity");
+    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorSeverity", json);
   }
 
   @override
   String toString() => "AnalysisErrorSeverity.$name";
 
   String toJson() => name;
 }
 
 /**
  * AnalysisErrorType
@@ skipping 58 matching lines @@
   }
 
   factory AnalysisErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisErrorType(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorType");
+    throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorType", json);
   }
 
   @override
   String toString() => "AnalysisErrorType.$name";
 
   String toJson() => name;
 }
 
 /**
  * AnalysisOptions
@@ skipping 167 matching lines @@
       bool generateHints;
       if (json.containsKey("generateHints")) {
         generateHints = jsonDecoder._decodeBool(jsonPath + ".generateHints", json["generateHints"]);
       }
       bool generateLints;
       if (json.containsKey("generateLints")) {
         generateLints = jsonDecoder._decodeBool(jsonPath + ".generateLints", json["generateLints"]);
       }
       return new AnalysisOptions(enableAsync: enableAsync, enableDeferredLoading: enableDeferredLoading, enableEnums: enableEnums, enableNullAwareOperators: enableNullAwareOperators, generateDart2jsHints: generateDart2jsHints, generateHints: generateHints, generateLints: generateLints);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "AnalysisOptions");
+      throw jsonDecoder.mismatch(jsonPath, "AnalysisOptions", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (enableAsync != null) {
       result["enableAsync"] = enableAsync;
     }
     if (enableDeferredLoading != null) {
       result["enableDeferredLoading"] = enableDeferredLoading;
@@ skipping 109 matching lines @@
   }
 
   factory AnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new AnalysisService(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "AnalysisService");
+    throw jsonDecoder.mismatch(jsonPath, "AnalysisService", json);
   }
 
   @override
   String toString() => "AnalysisService.$name";
 
   String toJson() => name;
 }
 
 /**
  * AnalysisStatus
@@ skipping 50 matching lines @@
         isAnalyzing = jsonDecoder._decodeBool(jsonPath + ".isAnalyzing", json["isAnalyzing"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isAnalyzing");
       }
       String analysisTarget;
       if (json.containsKey("analysisTarget")) {
         analysisTarget = jsonDecoder._decodeString(jsonPath + ".analysisTarget", json["analysisTarget"]);
       }
       return new AnalysisStatus(isAnalyzing, analysisTarget: analysisTarget);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "AnalysisStatus");
+      throw jsonDecoder.mismatch(jsonPath, "AnalysisStatus", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isAnalyzing"] = isAnalyzing;
     if (analysisTarget != null) {
       result["analysisTarget"] = analysisTarget;
     }
     return result;
@@ skipping 47 matching lines @@
   ChangeContentOverlay(List<SourceEdit> edits) {
     this.edits = 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");
+        throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json);
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
         edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       return new ChangeContentOverlay(edits);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay");
+      throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "change";
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
 
@@ skipping 470 matching lines @@
       String parameterType;
       if (json.containsKey("parameterType")) {
         parameterType = jsonDecoder._decodeString(jsonPath + ".parameterType", json["parameterType"]);
       }
       String importUri;
       if (json.containsKey("importUri")) {
         importUri = jsonDecoder._decodeString(jsonPath + ".importUri", json["importUri"]);
       }
       return new CompletionSuggestion(kind, relevance, completion, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary: docSummary, docComplete: docComplete, declaringType: declaringType, element: element, returnType: returnType, parameterNames: parameterNames, parameterTypes: parameterTypes, requiredParameterCount: requiredParameterCount, hasNamedParameters: hasNamedParameters, parameterName: parameterName, parameterType: parameterType, importUri: importUri);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion");
+      throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["relevance"] = relevance;
     result["completion"] = completion;
     result["selectionOffset"] = selectionOffset;
     result["selectionLength"] = selectionLength;
@@ skipping 183 matching lines @@
   }
 
   factory CompletionSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new CompletionSuggestionKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestionKind");
+    throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestionKind", json);
   }
 
   @override
   String toString() => "CompletionSuggestionKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * Element
@@ skipping 202 matching lines @@
       String returnType;
       if (json.containsKey("returnType")) {
         returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
       }
       String typeParameters;
       if (json.containsKey("typeParameters")) {
         typeParameters = jsonDecoder._decodeString(jsonPath + ".typeParameters", json["typeParameters"]);
       }
       return new Element(kind, name, flags, location: location, parameters: parameters, returnType: returnType, typeParameters: typeParameters);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Element");
+      throw jsonDecoder.mismatch(jsonPath, "Element", json);
     }
   }
 
   bool get isAbstract => (flags & FLAG_ABSTRACT) != 0;
   bool get isConst => (flags & FLAG_CONST) != 0;
   bool get isFinal => (flags & FLAG_FINAL) != 0;
   bool get isStatic => (flags & FLAG_STATIC) != 0;
   bool get isPrivate => (flags & FLAG_PRIVATE) != 0;
   bool get isDeprecated => (flags & FLAG_DEPRECATED) != 0;
 
@@ skipping 181 matching lines @@
   }
 
   factory ElementKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new ElementKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "ElementKind");
+    throw jsonDecoder.mismatch(jsonPath, "ElementKind", json);
   }
 
   @override
   String toString() => "ElementKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * ExecutableFile
@@ skipping 51 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       ExecutableKind kind;
       if (json.containsKey("kind")) {
         kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       return new ExecutableFile(file, kind);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "ExecutableFile");
+      throw jsonDecoder.mismatch(jsonPath, "ExecutableFile", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["kind"] = kind.toJson();
     return result;
   }
 
@@ skipping 61 matching lines @@
   }
 
   factory ExecutableKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new ExecutableKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "ExecutableKind");
+    throw jsonDecoder.mismatch(jsonPath, "ExecutableKind", json);
   }
 
   @override
   String toString() => "ExecutableKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * ExecutionService
@@ skipping 23 matching lines @@
   }
 
   factory ExecutionService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new ExecutionService(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "ExecutionService");
+    throw jsonDecoder.mismatch(jsonPath, "ExecutionService", json);
   }
 
   @override
   String toString() => "ExecutionService.$name";
 
   String toJson() => name;
 }
 
 /**
  * FoldingKind
@@ skipping 43 matching lines @@
   }
 
   factory FoldingKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new FoldingKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "FoldingKind");
+    throw jsonDecoder.mismatch(jsonPath, "FoldingKind", json);
   }
 
   @override
   String toString() => "FoldingKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * FoldingRegion
@@ skipping 74 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new FoldingRegion(kind, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "FoldingRegion");
+      throw jsonDecoder.mismatch(jsonPath, "FoldingRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
@@ skipping 49 matching lines @@
   }
 
   factory GeneralAnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new GeneralAnalysisService(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "GeneralAnalysisService");
+    throw jsonDecoder.mismatch(jsonPath, "GeneralAnalysisService", json);
   }
 
   @override
   String toString() => "GeneralAnalysisService.$name";
 
   String toJson() => name;
 }
 
 /**
  * HighlightRegion
@@ skipping 74 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       int length;
       if (json.containsKey("length")) {
         length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       return new HighlightRegion(type, offset, length);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "HighlightRegion");
+      throw jsonDecoder.mismatch(jsonPath, "HighlightRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = type.toJson();
     result["offset"] = offset;
     result["length"] = length;
     return result;
   }
@@ skipping 234 matching lines @@
   }
 
   factory HighlightRegionType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new HighlightRegionType(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "HighlightRegionType");
+    throw jsonDecoder.mismatch(jsonPath, "HighlightRegionType", json);
   }
 
   @override
   String toString() => "HighlightRegionType.$name";
 
   String toJson() => name;
 }
 
 /**
  * HoverInformation
@@ skipping 269 matching lines @@
       String propagatedType;
       if (json.containsKey("propagatedType")) {
         propagatedType = jsonDecoder._decodeString(jsonPath + ".propagatedType", json["propagatedType"]);
       }
       String staticType;
       if (json.containsKey("staticType")) {
         staticType = jsonDecoder._decodeString(jsonPath + ".staticType", json["staticType"]);
       }
       return new HoverInformation(offset, length, containingLibraryPath: containingLibraryPath, containingLibraryName: containingLibraryName, containingClassDescription: containingClassDescription, dartdoc: dartdoc, elementDescription: elementDescription, elementKind: elementKind, parameter: parameter, propagatedType: propagatedType, staticType: staticType);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "HoverInformation");
+      throw jsonDecoder.mismatch(jsonPath, "HoverInformation", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     if (containingLibraryPath != null) {
       result["containingLibraryPath"] = containingLibraryPath;
     }
@@ skipping 144 matching lines @@
         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");
       }
       return new LinkedEditGroup(positions, length, suggestions);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup");
+      throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json);
     }
   }
 
   /**
    * Construct an empty LinkedEditGroup.
    */
   LinkedEditGroup.empty() : this(<Position>[], 0, <LinkedEditSuggestion>[]);
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 97 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "value");
       }
       LinkedEditSuggestionKind kind;
       if (json.containsKey("kind")) {
         kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "kind");
       }
       return new LinkedEditSuggestion(value, kind);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestion");
+      throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["value"] = value;
     result["kind"] = kind.toJson();
     return result;
   }
 
@@ skipping 61 matching lines @@
   }
 
   factory LinkedEditSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new LinkedEditSuggestionKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestionKind");
+    throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestionKind", json);
   }
 
   @override
   String toString() => "LinkedEditSuggestionKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * Location
@@ skipping 124 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
         startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startColumn");
       }
       return new Location(file, offset, length, startLine, startColumn);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Location");
+      throw jsonDecoder.mismatch(jsonPath, "Location", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     result["length"] = length;
     result["startLine"] = startLine;
     result["startColumn"] = startColumn;
@@ skipping 110 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "length");
       }
       List<int> targets;
       if (json.containsKey("targets")) {
         targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "targets");
       }
       return new NavigationRegion(offset, length, targets);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "NavigationRegion");
+      throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["targets"] = targets;
     return result;
   }
@@ skipping 175 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "startLine");
       }
       int startColumn;
       if (json.containsKey("startColumn")) {
         startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["startColumn"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "startColumn");
       }
       return new NavigationTarget(kind, fileIndex, offset, length, startLine, startColumn);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "NavigationTarget");
+      throw jsonDecoder.mismatch(jsonPath, "NavigationTarget", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["kind"] = kind.toJson();
     result["fileIndex"] = fileIndex;
     result["offset"] = offset;
     result["length"] = length;
     result["startLine"] = startLine;
@@ skipping 109 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       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);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Occurrences");
+      throw jsonDecoder.mismatch(jsonPath, "Occurrences", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offsets"] = offsets;
     result["length"] = length;
     return result;
   }
@@ skipping 128 matching lines @@
         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));
       }
       return new Outline(element, offset, length, children: children);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Outline");
+      throw jsonDecoder.mismatch(jsonPath, "Outline", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["offset"] = offset;
     result["length"] = length;
     if (children != null) {
       result["children"] = children.map((Outline value) => value.toJson()).toList();
@@ skipping 130 matching lines @@
       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));
       }
       return new Override(offset, length, superclassMember: superclassMember, interfaceMembers: interfaceMembers);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Override");
+      throw jsonDecoder.mismatch(jsonPath, "Override", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     if (superclassMember != null) {
       result["superclassMember"] = superclassMember.toJson();
     }
@@ skipping 84 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "element");
       }
       String className;
       if (json.containsKey("className")) {
         className = jsonDecoder._decodeString(jsonPath + ".className", json["className"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "className");
       }
       return new OverriddenMember(element, className);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "OverriddenMember");
+      throw jsonDecoder.mismatch(jsonPath, "OverriddenMember", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["element"] = element.toJson();
     result["className"] = className;
     return result;
   }
 
@@ skipping 74 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "file");
       }
       int offset;
       if (json.containsKey("offset")) {
         offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "offset");
       }
       return new Position(file, offset);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "Position");
+      throw jsonDecoder.mismatch(jsonPath, "Position", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["offset"] = offset;
     return result;
   }
 
@@ skipping 53 matching lines @@
     }
     if (json is Map) {
       bool isListingPackageDirs;
       if (json.containsKey("isListingPackageDirs")) {
         isListingPackageDirs = jsonDecoder._decodeBool(jsonPath + ".isListingPackageDirs", json["isListingPackageDirs"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isListingPackageDirs");
       }
       return new PubStatus(isListingPackageDirs);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "PubStatus");
+      throw jsonDecoder.mismatch(jsonPath, "PubStatus", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["isListingPackageDirs"] = isListingPackageDirs;
     return result;
   }
 
   @override
@@ skipping 83 matching lines @@
   }
 
   factory RefactoringKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "RefactoringKind");
+    throw jsonDecoder.mismatch(jsonPath, "RefactoringKind", json);
   }
 
   @override
   String toString() => "RefactoringKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * RefactoringMethodParameter
@@ skipping 122 matching lines @@
         name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       String parameters;
       if (json.containsKey("parameters")) {
         parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["parameters"]);
       }
       return new RefactoringMethodParameter(kind, type, name, id: id, parameters: parameters);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter");
+      throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (id != null) {
       result["id"] = id;
     }
     result["kind"] = kind.toJson();
     result["type"] = type;
@@ skipping 141 matching lines @@
   }
 
   factory RefactoringMethodParameterKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringMethodParameterKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameterKind");
+    throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameterKind", json);
   }
 
   @override
   String toString() => "RefactoringMethodParameterKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * RefactoringProblem
@@ skipping 75 matching lines @@
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       Location location;
       if (json.containsKey("location")) {
         location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
       }
       return new RefactoringProblem(severity, message, location: location);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem");
+      throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["severity"] = severity.toJson();
     result["message"] = message;
     if (location != null) {
       result["location"] = location.toJson();
     }
@@ skipping 66 matching lines @@
   }
 
   factory RefactoringProblemSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RefactoringProblemSeverity(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity");
+    throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity", json);
   }
 
   /**
    * Returns the [RefactoringProblemSeverity] with the maximal severity.
    */
   static RefactoringProblemSeverity max(RefactoringProblemSeverity a, RefactoringProblemSeverity b) =>
       _maxRefactoringProblemSeverity(a, b);
 
   @override
   String toString() => "RefactoringProblemSeverity.$name";
@@ skipping 10 matching lines @@
  */
 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");
+        throw jsonDecoder.mismatch(jsonPath, "equal " + "remove", json);
       }
       return new RemoveContentOverlay();
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay");
+      throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["type"] = "remove";
     return result;
   }
 
   @override
@@ skipping 93 matching lines @@
         message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "message");
       }
       String stackTrace;
       if (json.containsKey("stackTrace")) {
         stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
       }
       return new RequestError(code, message, stackTrace: stackTrace);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "RequestError");
+      throw jsonDecoder.mismatch(jsonPath, "RequestError", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["code"] = code.toJson();
     result["message"] = message;
     if (stackTrace != null) {
       result["stackTrace"] = stackTrace;
     }
@@ skipping 233 matching lines @@
   }
 
   factory RequestErrorCode.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new RequestErrorCode(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "RequestErrorCode");
+    throw jsonDecoder.mismatch(jsonPath, "RequestErrorCode", json);
   }
 
   @override
   String toString() => "RequestErrorCode.$name";
 
   String toJson() => name;
 }
 
 /**
  * SearchResult
@@ skipping 107 matching lines @@
         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");
       }
       return new SearchResult(location, kind, isPotential, path);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "SearchResult");
+      throw jsonDecoder.mismatch(jsonPath, "SearchResult", json);
     }
   }
 
   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();
     return result;
@@ skipping 104 matching lines @@
   }
 
   factory SearchResultKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new SearchResultKind(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "SearchResultKind");
+    throw jsonDecoder.mismatch(jsonPath, "SearchResultKind", json);
   }
 
   @override
   String toString() => "SearchResultKind.$name";
 
   String toJson() => name;
 }
 
 /**
  * ServerService
@@ skipping 23 matching lines @@
   }
 
   factory ServerService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
     if (json is String) {
       try {
         return new ServerService(json);
       } catch(_) {
         // Fall through
       }
     }
-    throw jsonDecoder.mismatch(jsonPath, "ServerService");
+    throw jsonDecoder.mismatch(jsonPath, "ServerService", json);
   }
 
   @override
   String toString() => "ServerService.$name";
 
   String toJson() => name;
 }
 
 /**
  * SourceChange
@@ skipping 104 matching lines @@
         linkedEditGroups = jsonDecoder._decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups");
       }
       Position selection;
       if (json.containsKey("selection")) {
         selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
       }
       return new SourceChange(message, edits: edits, linkedEditGroups: linkedEditGroups, selection: selection);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "SourceChange");
+      throw jsonDecoder.mismatch(jsonPath, "SourceChange", json);
     }
   }
 
   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 (selection != null) {
       result["selection"] = selection.toJson();
@@ skipping 172 matching lines @@
         replacement = jsonDecoder._decodeString(jsonPath + ".replacement", json["replacement"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "replacement");
       }
       String id;
       if (json.containsKey("id")) {
         id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
       }
       return new SourceEdit(offset, length, replacement, id: id);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "SourceEdit");
+      throw jsonDecoder.mismatch(jsonPath, "SourceEdit", json);
     }
   }
 
   /**
    * The end of the region to be modified.
    */
   int get end => offset + length;
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 127 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "fileStamp");
       }
       List<SourceEdit> edits;
       if (json.containsKey("edits")) {
         edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
       } else {
         throw jsonDecoder.missingKey(jsonPath, "edits");
       }
       return new SourceFileEdit(file, fileStamp, edits: edits);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit");
+      throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["file"] = file;
     result["fileStamp"] = fileStamp;
     result["edits"] = edits.map((SourceEdit value) => value.toJson()).toList();
     return result;
   }
@@ skipping 228 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "mixins");
       }
       List<int> subclasses;
       if (json.containsKey("subclasses")) {
         subclasses = jsonDecoder._decodeList(jsonPath + ".subclasses", json["subclasses"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "subclasses");
       }
       return new TypeHierarchyItem(classElement, displayName: displayName, memberElement: memberElement, superclass: superclass, interfaces: interfaces, mixins: mixins, subclasses: subclasses);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem");
+      throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["classElement"] = classElement.toJson();
     if (displayName != null) {
       result["displayName"] = displayName;
     }
     if (memberElement != null) {
@@ skipping 194 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractLocalVariableFeedback(names, offsets, lengths);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback");
+      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["names"] = names;
     result["offsets"] = offsets;
     result["lengths"] = lengths;
     return result;
   }
@@ skipping 83 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       bool extractAll;
       if (json.containsKey("extractAll")) {
         extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "extractAll");
       }
       return new ExtractLocalVariableOptions(name, extractAll);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options");
+      throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options", json);
     }
   }
 
   factory ExtractLocalVariableOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
     return new ExtractLocalVariableOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 231 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "offsets");
       }
       List<int> lengths;
       if (json.containsKey("lengths")) {
         lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "lengths");
       }
       return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, offsets, lengths);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback");
+      throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["returnType"] = returnType;
     result["names"] = names;
     result["canCreateGetter"] = canCreateGetter;
@@ skipping 185 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "parameters");
       }
       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);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "extractMethod options");
+      throw jsonDecoder.mismatch(jsonPath, "extractMethod options", json);
     }
   }
 
   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 = {};
@@ skipping 88 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "name");
       }
       int occurrences;
       if (json.containsKey("occurrences")) {
         occurrences = jsonDecoder._decodeInt(jsonPath + ".occurrences", json["occurrences"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "occurrences");
       }
       return new InlineLocalVariableFeedback(name, occurrences);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "inlineLocalVariable feedback");
+      throw jsonDecoder.mismatch(jsonPath, "inlineLocalVariable feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["name"] = name;
     result["occurrences"] = occurrences;
     return result;
   }
 
@@ skipping 115 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "methodName");
       }
       bool isDeclaration;
       if (json.containsKey("isDeclaration")) {
         isDeclaration = jsonDecoder._decodeBool(jsonPath + ".isDeclaration", json["isDeclaration"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "isDeclaration");
       }
       return new InlineMethodFeedback(methodName, isDeclaration, className: className);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "inlineMethod feedback");
+      throw jsonDecoder.mismatch(jsonPath, "inlineMethod feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     if (className != null) {
       result["className"] = className;
     }
     result["methodName"] = methodName;
     result["isDeclaration"] = isDeclaration;
@@ skipping 83 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "deleteSource");
       }
       bool inlineAll;
       if (json.containsKey("inlineAll")) {
         inlineAll = jsonDecoder._decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "inlineAll");
       }
       return new InlineMethodOptions(deleteSource, inlineAll);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "inlineMethod options");
+      throw jsonDecoder.mismatch(jsonPath, "inlineMethod options", json);
     }
   }
 
   factory InlineMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
     return new InlineMethodOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 73 matching lines @@
     }
     if (json is Map) {
       String newFile;
       if (json.containsKey("newFile")) {
         newFile = jsonDecoder._decodeString(jsonPath + ".newFile", json["newFile"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "newFile");
       }
       return new MoveFileOptions(newFile);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "moveFile options");
+      throw jsonDecoder.mismatch(jsonPath, "moveFile options", json);
     }
   }
 
   factory MoveFileOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
     return new MoveFileOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 124 matching lines @@
         throw jsonDecoder.missingKey(jsonPath, "elementKindName");
       }
       String oldName;
       if (json.containsKey("oldName")) {
         oldName = jsonDecoder._decodeString(jsonPath + ".oldName", json["oldName"]);
       } else {
         throw jsonDecoder.missingKey(jsonPath, "oldName");
       }
       return new RenameFeedback(offset, length, elementKindName, oldName);
     } else {
-      throw jsonDecoder.mismatch(jsonPath, "rename feedback");
+      throw jsonDecoder.mismatch(jsonPath, "rename feedback", json);
     }
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
     result["offset"] = offset;
     result["length"] = length;
     result["elementKindName"] = elementKindName;
     result["oldName"] = oldName;
     return result;
@@ skipping 57 matching lines @@
     }
     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");
+      throw jsonDecoder.mismatch(jsonPath, "rename options", json);
     }
   }
 
   factory RenameOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
     return new RenameOptions.fromJson(
         new RequestDecoder(request), "options", refactoringParams.options);
   }
 
   Map<String, dynamic> toJson() {
     Map<String, dynamic> result = {};
@@ skipping 12 matching lines @@
     return false;
   }
 
   @override
   int get hashCode {
     int hash = 0;
     hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
     return _JenkinsSmiHash.finish(hash);
   }
 }