Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1131)

Side by Side Diff: pkg/analysis_server/lib/plugin/protocol/generated_protocol.dart

Issue 1852473002: Fix generated server code to be strong mode compliant (Closed) Base URL: https://github.com/dart-lang/sdk.git@master
Patch Set: Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
2 // for details. All rights reserved. Use of this source code is governed by a 2 // for details. All rights reserved. Use of this source code is governed by a
3 // BSD-style license that can be found in the LICENSE file. 3 // BSD-style license that can be found in the LICENSE file.
4 // 4 //
5 // This file has been automatically generated. Please do not edit it manually. 5 // This file has been automatically generated. Please do not edit it manually.
6 // To regenerate the file, use the script 6 // To regenerate the file, use the script
7 // "pkg/analysis_server/tool/spec/generate_files". 7 // "pkg/analysis_server/tool/spec/generate_files".
8 8
9 part of analysis_server.plugin.protocol.protocol; 9 part of analysis_server.plugin.protocol.protocol;
10 10
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after
187 this.subscriptions = subscriptions; 187 this.subscriptions = subscriptions;
188 } 188 }
189 189
190 factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) { 190 factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
191 if (json == null) { 191 if (json == null) {
192 json = {}; 192 json = {};
193 } 193 }
194 if (json is Map) { 194 if (json is Map) {
195 List<ServerService> subscriptions; 195 List<ServerService> subscriptions;
196 if (json.containsKey("subscriptions")) { 196 if (json.containsKey("subscriptions")) {
197 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson( jsonDecoder, jsonPath, json)); 197 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson( jsonDecoder, jsonPath, json)) as List<ServerService>;
198 } else { 198 } else {
199 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); 199 throw jsonDecoder.missingKey(jsonPath, "subscriptions");
200 } 200 }
201 return new ServerSetSubscriptionsParams(subscriptions); 201 return new ServerSetSubscriptionsParams(subscriptions);
202 } else { 202 } else {
203 throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params", jso n); 203 throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params", jso n);
204 } 204 }
205 } 205 }
206 206
207 factory ServerSetSubscriptionsParams.fromRequest(Request request) { 207 factory ServerSetSubscriptionsParams.fromRequest(Request request) {
(...skipping 486 matching lines...) Expand 10 before | Expand all | Expand 10 after
694 this.errors = errors; 694 this.errors = errors;
695 } 695 }
696 696
697 factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonP ath, Object json) { 697 factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonP ath, Object json) {
698 if (json == null) { 698 if (json == null) {
699 json = {}; 699 json = {};
700 } 700 }
701 if (json is Map) { 701 if (json is Map) {
702 List<AnalysisError> errors; 702 List<AnalysisError> errors;
703 if (json.containsKey("errors")) { 703 if (json.containsKey("errors")) {
704 errors = jsonDecoder.decodeList(jsonPath + ".errors", json["errors"], (S tring jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath , json)); 704 errors = jsonDecoder.decodeList(jsonPath + ".errors", json["errors"], (S tring jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath , json)) as List<AnalysisError>;
705 } else { 705 } else {
706 throw jsonDecoder.missingKey(jsonPath, "errors"); 706 throw jsonDecoder.missingKey(jsonPath, "errors");
707 } 707 }
708 return new AnalysisGetErrorsResult(errors); 708 return new AnalysisGetErrorsResult(errors);
709 } else { 709 } else {
710 throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result", json); 710 throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result", json);
711 } 711 }
712 } 712 }
713 713
714 factory AnalysisGetErrorsResult.fromResponse(Response response) { 714 factory AnalysisGetErrorsResult.fromResponse(Response response) {
(...skipping 173 matching lines...) Expand 10 before | Expand all | Expand 10 after
888 this.hovers = hovers; 888 this.hovers = hovers;
889 } 889 }
890 890
891 factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPa th, Object json) { 891 factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPa th, Object json) {
892 if (json == null) { 892 if (json == null) {
893 json = {}; 893 json = {};
894 } 894 }
895 if (json is Map) { 895 if (json is Map) {
896 List<HoverInformation> hovers; 896 List<HoverInformation> hovers;
897 if (json.containsKey("hovers")) { 897 if (json.containsKey("hovers")) {
898 hovers = jsonDecoder.decodeList(jsonPath + ".hovers", json["hovers"], (S tring jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonP ath, json)); 898 hovers = jsonDecoder.decodeList(jsonPath + ".hovers", json["hovers"], (S tring jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonP ath, json)) as List<HoverInformation>;
899 } else { 899 } else {
900 throw jsonDecoder.missingKey(jsonPath, "hovers"); 900 throw jsonDecoder.missingKey(jsonPath, "hovers");
901 } 901 }
902 return new AnalysisGetHoverResult(hovers); 902 return new AnalysisGetHoverResult(hovers);
903 } else { 903 } else {
904 throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result", json); 904 throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result", json);
905 } 905 }
906 } 906 }
907 907
908 factory AnalysisGetHoverResult.fromResponse(Response response) { 908 factory AnalysisGetHoverResult.fromResponse(Response response) {
(...skipping 149 matching lines...) Expand 10 before | Expand all | Expand 10 after
1058 this.sources = sources; 1058 this.sources = sources;
1059 } 1059 }
1060 1060
1061 factory AnalysisGetReachableSourcesResult.fromJson(JsonDecoder jsonDecoder, St ring jsonPath, Object json) { 1061 factory AnalysisGetReachableSourcesResult.fromJson(JsonDecoder jsonDecoder, St ring jsonPath, Object json) {
1062 if (json == null) { 1062 if (json == null) {
1063 json = {}; 1063 json = {};
1064 } 1064 }
1065 if (json is Map) { 1065 if (json is Map) {
1066 Map<String, List<String>> sources; 1066 Map<String, List<String>> sources;
1067 if (json.containsKey("sources")) { 1067 if (json.containsKey("sources")) {
1068 sources = jsonDecoder.decodeMap(jsonPath + ".sources", json["sources"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString)); 1068 sources = jsonDecoder.decodeMap(jsonPath + ".sources", json["sources"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString) as List<String>) as Map<String, List<String>>;
1069 } else { 1069 } else {
1070 throw jsonDecoder.missingKey(jsonPath, "sources"); 1070 throw jsonDecoder.missingKey(jsonPath, "sources");
1071 } 1071 }
1072 return new AnalysisGetReachableSourcesResult(sources); 1072 return new AnalysisGetReachableSourcesResult(sources);
1073 } else { 1073 } else {
1074 throw jsonDecoder.mismatch(jsonPath, "analysis.getReachableSources result" , json); 1074 throw jsonDecoder.mismatch(jsonPath, "analysis.getReachableSources result" , json);
1075 } 1075 }
1076 } 1076 }
1077 1077
1078 factory AnalysisGetReachableSourcesResult.fromResponse(Response response) { 1078 factory AnalysisGetReachableSourcesResult.fromResponse(Response response) {
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after
1182 this.packageMap = packageMap; 1182 this.packageMap = packageMap;
1183 } 1183 }
1184 1184
1185 factory AnalysisGetLibraryDependenciesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) { 1185 factory AnalysisGetLibraryDependenciesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
1186 if (json == null) { 1186 if (json == null) {
1187 json = {}; 1187 json = {};
1188 } 1188 }
1189 if (json is Map) { 1189 if (json is Map) {
1190 List<String> libraries; 1190 List<String> libraries;
1191 if (json.containsKey("libraries")) { 1191 if (json.containsKey("libraries")) {
1192 libraries = jsonDecoder.decodeList(jsonPath + ".libraries", json["librar ies"], jsonDecoder.decodeString); 1192 libraries = jsonDecoder.decodeList(jsonPath + ".libraries", json["librar ies"], jsonDecoder.decodeString) as List<String>;
1193 } else { 1193 } else {
1194 throw jsonDecoder.missingKey(jsonPath, "libraries"); 1194 throw jsonDecoder.missingKey(jsonPath, "libraries");
1195 } 1195 }
1196 Map<String, Map<String, List<String>>> packageMap; 1196 Map<String, Map<String, List<String>>> packageMap;
1197 if (json.containsKey("packageMap")) { 1197 if (json.containsKey("packageMap")) {
1198 packageMap = jsonDecoder.decodeMap(jsonPath + ".packageMap", json["packa geMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeMap(j sonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder.decod eList(jsonPath, json, jsonDecoder.decodeString))); 1198 packageMap = jsonDecoder.decodeMap(jsonPath + ".packageMap", json["packa geMap"], valueDecoder: (String jsonPath, Object json) => jsonDecoder.decodeMap(j sonPath, json, valueDecoder: (String jsonPath, Object json) => jsonDecoder.decod eList(jsonPath, json, jsonDecoder.decodeString) as List<String>) as Map<String, List<String>>) as Map<String, Map<String, List<String>>>;
1199 } else { 1199 } else {
1200 throw jsonDecoder.missingKey(jsonPath, "packageMap"); 1200 throw jsonDecoder.missingKey(jsonPath, "packageMap");
1201 } 1201 }
1202 return new AnalysisGetLibraryDependenciesResult(libraries, packageMap); 1202 return new AnalysisGetLibraryDependenciesResult(libraries, packageMap);
1203 } else { 1203 } else {
1204 throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies resu lt", json); 1204 throw jsonDecoder.mismatch(jsonPath, "analysis.getLibraryDependencies resu lt", json);
1205 } 1205 }
1206 } 1206 }
1207 1207
1208 factory AnalysisGetLibraryDependenciesResult.fromResponse(Response response) { 1208 factory AnalysisGetLibraryDependenciesResult.fromResponse(Response response) {
(...skipping 236 matching lines...) Expand 10 before | Expand all | Expand 10 after
1445 this.regions = regions; 1445 this.regions = regions;
1446 } 1446 }
1447 1447
1448 factory AnalysisGetNavigationResult.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) { 1448 factory AnalysisGetNavigationResult.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) {
1449 if (json == null) { 1449 if (json == null) {
1450 json = {}; 1450 json = {};
1451 } 1451 }
1452 if (json is Map) { 1452 if (json is Map) {
1453 List<String> files; 1453 List<String> files;
1454 if (json.containsKey("files")) { 1454 if (json.containsKey("files")) {
1455 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString); 1455 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString) as List<String>;
1456 } else { 1456 } else {
1457 throw jsonDecoder.missingKey(jsonPath, "files"); 1457 throw jsonDecoder.missingKey(jsonPath, "files");
1458 } 1458 }
1459 List<NavigationTarget> targets; 1459 List<NavigationTarget> targets;
1460 if (json.containsKey("targets")) { 1460 if (json.containsKey("targets")) {
1461 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, js onPath, json)); 1461 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, js onPath, json)) as List<NavigationTarget>;
1462 } else { 1462 } else {
1463 throw jsonDecoder.missingKey(jsonPath, "targets"); 1463 throw jsonDecoder.missingKey(jsonPath, "targets");
1464 } 1464 }
1465 List<NavigationRegion> regions; 1465 List<NavigationRegion> regions;
1466 if (json.containsKey("regions")) { 1466 if (json.containsKey("regions")) {
1467 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, js onPath, json)); 1467 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, js onPath, json)) as List<NavigationRegion>;
1468 } else { 1468 } else {
1469 throw jsonDecoder.missingKey(jsonPath, "regions"); 1469 throw jsonDecoder.missingKey(jsonPath, "regions");
1470 } 1470 }
1471 return new AnalysisGetNavigationResult(files, targets, regions); 1471 return new AnalysisGetNavigationResult(files, targets, regions);
1472 } else { 1472 } else {
1473 throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result", json ); 1473 throw jsonDecoder.mismatch(jsonPath, "analysis.getNavigation result", json );
1474 } 1474 }
1475 } 1475 }
1476 1476
1477 factory AnalysisGetNavigationResult.fromResponse(Response response) { 1477 factory AnalysisGetNavigationResult.fromResponse(Response response) {
(...skipping 64 matching lines...) Expand 10 before | Expand all | Expand 10 after
1542 this.roots = roots; 1542 this.roots = roots;
1543 } 1543 }
1544 1544
1545 factory AnalysisReanalyzeParams.fromJson(JsonDecoder jsonDecoder, String jsonP ath, Object json) { 1545 factory AnalysisReanalyzeParams.fromJson(JsonDecoder jsonDecoder, String jsonP ath, Object json) {
1546 if (json == null) { 1546 if (json == null) {
1547 json = {}; 1547 json = {};
1548 } 1548 }
1549 if (json is Map) { 1549 if (json is Map) {
1550 List<String> roots; 1550 List<String> roots;
1551 if (json.containsKey("roots")) { 1551 if (json.containsKey("roots")) {
1552 roots = jsonDecoder.decodeList(jsonPath + ".roots", json["roots"], jsonD ecoder.decodeString); 1552 roots = jsonDecoder.decodeList(jsonPath + ".roots", json["roots"], jsonD ecoder.decodeString) as List<String>;
1553 } 1553 }
1554 return new AnalysisReanalyzeParams(roots: roots); 1554 return new AnalysisReanalyzeParams(roots: roots);
1555 } else { 1555 } else {
1556 throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json); 1556 throw jsonDecoder.mismatch(jsonPath, "analysis.reanalyze params", json);
1557 } 1557 }
1558 } 1558 }
1559 1559
1560 factory AnalysisReanalyzeParams.fromRequest(Request request) { 1560 factory AnalysisReanalyzeParams.fromRequest(Request request) {
1561 return new AnalysisReanalyzeParams.fromJson( 1561 return new AnalysisReanalyzeParams.fromJson(
1562 new RequestDecoder(request), "params", request._params); 1562 new RequestDecoder(request), "params", request._params);
(...skipping 153 matching lines...) Expand 10 before | Expand all | Expand 10 after
1716 this.packageRoots = packageRoots; 1716 this.packageRoots = packageRoots;
1717 } 1717 }
1718 1718
1719 factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) { 1719 factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) {
1720 if (json == null) { 1720 if (json == null) {
1721 json = {}; 1721 json = {};
1722 } 1722 }
1723 if (json is Map) { 1723 if (json is Map) {
1724 List<String> included; 1724 List<String> included;
1725 if (json.containsKey("included")) { 1725 if (json.containsKey("included")) {
1726 included = jsonDecoder.decodeList(jsonPath + ".included", json["included "], jsonDecoder.decodeString); 1726 included = jsonDecoder.decodeList(jsonPath + ".included", json["included "], jsonDecoder.decodeString) as List<String>;
1727 } else { 1727 } else {
1728 throw jsonDecoder.missingKey(jsonPath, "included"); 1728 throw jsonDecoder.missingKey(jsonPath, "included");
1729 } 1729 }
1730 List<String> excluded; 1730 List<String> excluded;
1731 if (json.containsKey("excluded")) { 1731 if (json.containsKey("excluded")) {
1732 excluded = jsonDecoder.decodeList(jsonPath + ".excluded", json["excluded "], jsonDecoder.decodeString); 1732 excluded = jsonDecoder.decodeList(jsonPath + ".excluded", json["excluded "], jsonDecoder.decodeString) as List<String>;
1733 } else { 1733 } else {
1734 throw jsonDecoder.missingKey(jsonPath, "excluded"); 1734 throw jsonDecoder.missingKey(jsonPath, "excluded");
1735 } 1735 }
1736 Map<String, String> packageRoots; 1736 Map<String, String> packageRoots;
1737 if (json.containsKey("packageRoots")) { 1737 if (json.containsKey("packageRoots")) {
1738 packageRoots = jsonDecoder.decodeMap(jsonPath + ".packageRoots", json["p ackageRoots"], valueDecoder: jsonDecoder.decodeString); 1738 packageRoots = jsonDecoder.decodeMap(jsonPath + ".packageRoots", json["p ackageRoots"], valueDecoder: jsonDecoder.decodeString) as Map<String, String>;
1739 } 1739 }
1740 return new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots : packageRoots); 1740 return new AnalysisSetAnalysisRootsParams(included, excluded, packageRoots : packageRoots);
1741 } else { 1741 } else {
1742 throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params", j son); 1742 throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params", j son);
1743 } 1743 }
1744 } 1744 }
1745 1745
1746 factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) { 1746 factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
1747 return new AnalysisSetAnalysisRootsParams.fromJson( 1747 return new AnalysisSetAnalysisRootsParams.fromJson(
1748 new RequestDecoder(request), "params", request._params); 1748 new RequestDecoder(request), "params", request._params);
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
1837 this.subscriptions = subscriptions; 1837 this.subscriptions = subscriptions;
1838 } 1838 }
1839 1839
1840 factory AnalysisSetGeneralSubscriptionsParams.fromJson(JsonDecoder jsonDecoder , String jsonPath, Object json) { 1840 factory AnalysisSetGeneralSubscriptionsParams.fromJson(JsonDecoder jsonDecoder , String jsonPath, Object json) {
1841 if (json == null) { 1841 if (json == null) {
1842 json = {}; 1842 json = {};
1843 } 1843 }
1844 if (json is Map) { 1844 if (json is Map) {
1845 List<GeneralAnalysisService> subscriptions; 1845 List<GeneralAnalysisService> subscriptions;
1846 if (json.containsKey("subscriptions")) { 1846 if (json.containsKey("subscriptions")) {
1847 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService. fromJson(jsonDecoder, jsonPath, json)); 1847 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new GeneralAnalysisService. fromJson(jsonDecoder, jsonPath, json)) as List<GeneralAnalysisService>;
1848 } else { 1848 } else {
1849 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); 1849 throw jsonDecoder.missingKey(jsonPath, "subscriptions");
1850 } 1850 }
1851 return new AnalysisSetGeneralSubscriptionsParams(subscriptions); 1851 return new AnalysisSetGeneralSubscriptionsParams(subscriptions);
1852 } else { 1852 } else {
1853 throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions par ams", json); 1853 throw jsonDecoder.mismatch(jsonPath, "analysis.setGeneralSubscriptions par ams", json);
1854 } 1854 }
1855 } 1855 }
1856 1856
1857 factory AnalysisSetGeneralSubscriptionsParams.fromRequest(Request request) { 1857 factory AnalysisSetGeneralSubscriptionsParams.fromRequest(Request request) {
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
1940 this.files = files; 1940 this.files = files;
1941 } 1941 }
1942 1942
1943 factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) { 1943 factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) {
1944 if (json == null) { 1944 if (json == null) {
1945 json = {}; 1945 json = {};
1946 } 1946 }
1947 if (json is Map) { 1947 if (json is Map) {
1948 List<String> files; 1948 List<String> files;
1949 if (json.containsKey("files")) { 1949 if (json.containsKey("files")) {
1950 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString); 1950 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString) as List<String>;
1951 } else { 1951 } else {
1952 throw jsonDecoder.missingKey(jsonPath, "files"); 1952 throw jsonDecoder.missingKey(jsonPath, "files");
1953 } 1953 }
1954 return new AnalysisSetPriorityFilesParams(files); 1954 return new AnalysisSetPriorityFilesParams(files);
1955 } else { 1955 } else {
1956 throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params", j son); 1956 throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params", j son);
1957 } 1957 }
1958 } 1958 }
1959 1959
1960 factory AnalysisSetPriorityFilesParams.fromRequest(Request request) { 1960 factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
2045 this.subscriptions = subscriptions; 2045 this.subscriptions = subscriptions;
2046 } 2046 }
2047 2047
2048 factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) { 2048 factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) {
2049 if (json == null) { 2049 if (json == null) {
2050 json = {}; 2050 json = {};
2051 } 2051 }
2052 if (json is Map) { 2052 if (json is Map) {
2053 Map<AnalysisService, List<String>> subscriptions; 2053 Map<AnalysisService, List<String>> subscriptions;
2054 if (json.containsKey("subscriptions")) { 2054 if (json.containsKey("subscriptions")) {
2055 subscriptions = jsonDecoder.decodeMap(jsonPath + ".subscriptions", json[ "subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisServ ice.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Objec t json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString)); 2055 subscriptions = jsonDecoder.decodeMap(jsonPath + ".subscriptions", json[ "subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisServ ice.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Objec t json) => jsonDecoder.decodeList(jsonPath, json, jsonDecoder.decodeString) as L ist<String>) as Map<AnalysisService, List<String>>;
2056 } else { 2056 } else {
2057 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); 2057 throw jsonDecoder.missingKey(jsonPath, "subscriptions");
2058 } 2058 }
2059 return new AnalysisSetSubscriptionsParams(subscriptions); 2059 return new AnalysisSetSubscriptionsParams(subscriptions);
2060 } else { 2060 } else {
2061 throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params", j son); 2061 throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params", j son);
2062 } 2062 }
2063 } 2063 }
2064 2064
2065 factory AnalysisSetSubscriptionsParams.fromRequest(Request request) { 2065 factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after
2150 this.files = files; 2150 this.files = files;
2151 } 2151 }
2152 2152
2153 factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) { 2153 factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) {
2154 if (json == null) { 2154 if (json == null) {
2155 json = {}; 2155 json = {};
2156 } 2156 }
2157 if (json is Map) { 2157 if (json is Map) {
2158 Map<String, dynamic> files; 2158 Map<String, dynamic> files;
2159 if (json.containsKey("files")) { 2159 if (json.containsKey("files")) {
2160 files = jsonDecoder.decodeMap(jsonPath + ".files", json["files"], valueD ecoder: (String jsonPath, Object json) => jsonDecoder.decodeUnion(jsonPath, json , "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJs on(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String j sonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath , json)})); 2160 files = jsonDecoder.decodeMap(jsonPath + ".files", json["files"], valueD ecoder: (String jsonPath, Object json) => jsonDecoder.decodeUnion(jsonPath, json , "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJs on(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String j sonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath , json)})) as Map<String, dynamic>;
2161 } else { 2161 } else {
2162 throw jsonDecoder.missingKey(jsonPath, "files"); 2162 throw jsonDecoder.missingKey(jsonPath, "files");
2163 } 2163 }
2164 return new AnalysisUpdateContentParams(files); 2164 return new AnalysisUpdateContentParams(files);
2165 } else { 2165 } else {
2166 throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params", json ); 2166 throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params", json );
2167 } 2167 }
2168 } 2168 }
2169 2169
2170 factory AnalysisUpdateContentParams.fromRequest(Request request) { 2170 factory AnalysisUpdateContentParams.fromRequest(Request request) {
(...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after
2387 this.directories = directories; 2387 this.directories = directories;
2388 } 2388 }
2389 2389
2390 factory AnalysisAnalyzedFilesParams.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) { 2390 factory AnalysisAnalyzedFilesParams.fromJson(JsonDecoder jsonDecoder, String j sonPath, Object json) {
2391 if (json == null) { 2391 if (json == null) {
2392 json = {}; 2392 json = {};
2393 } 2393 }
2394 if (json is Map) { 2394 if (json is Map) {
2395 List<String> directories; 2395 List<String> directories;
2396 if (json.containsKey("directories")) { 2396 if (json.containsKey("directories")) {
2397 directories = jsonDecoder.decodeList(jsonPath + ".directories", json["di rectories"], jsonDecoder.decodeString); 2397 directories = jsonDecoder.decodeList(jsonPath + ".directories", json["di rectories"], jsonDecoder.decodeString) as List<String>;
2398 } else { 2398 } else {
2399 throw jsonDecoder.missingKey(jsonPath, "directories"); 2399 throw jsonDecoder.missingKey(jsonPath, "directories");
2400 } 2400 }
2401 return new AnalysisAnalyzedFilesParams(directories); 2401 return new AnalysisAnalyzedFilesParams(directories);
2402 } else { 2402 } else {
2403 throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params", json ); 2403 throw jsonDecoder.mismatch(jsonPath, "analysis.analyzedFiles params", json );
2404 } 2404 }
2405 } 2405 }
2406 2406
2407 factory AnalysisAnalyzedFilesParams.fromNotification(Notification notification ) { 2407 factory AnalysisAnalyzedFilesParams.fromNotification(Notification notification ) {
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
2490 } 2490 }
2491 if (json is Map) { 2491 if (json is Map) {
2492 String file; 2492 String file;
2493 if (json.containsKey("file")) { 2493 if (json.containsKey("file")) {
2494 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 2494 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
2495 } else { 2495 } else {
2496 throw jsonDecoder.missingKey(jsonPath, "file"); 2496 throw jsonDecoder.missingKey(jsonPath, "file");
2497 } 2497 }
2498 List<AnalysisError> errors; 2498 List<AnalysisError> errors;
2499 if (json.containsKey("errors")) { 2499 if (json.containsKey("errors")) {
2500 errors = jsonDecoder.decodeList(jsonPath + ".errors", json["errors"], (S tring jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath , json)); 2500 errors = jsonDecoder.decodeList(jsonPath + ".errors", json["errors"], (S tring jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath , json)) as List<AnalysisError>;
2501 } else { 2501 } else {
2502 throw jsonDecoder.missingKey(jsonPath, "errors"); 2502 throw jsonDecoder.missingKey(jsonPath, "errors");
2503 } 2503 }
2504 return new AnalysisErrorsParams(file, errors); 2504 return new AnalysisErrorsParams(file, errors);
2505 } else { 2505 } else {
2506 throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json); 2506 throw jsonDecoder.mismatch(jsonPath, "analysis.errors params", json);
2507 } 2507 }
2508 } 2508 }
2509 2509
2510 factory AnalysisErrorsParams.fromNotification(Notification notification) { 2510 factory AnalysisErrorsParams.fromNotification(Notification notification) {
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after
2573 this.files = files; 2573 this.files = files;
2574 } 2574 }
2575 2575
2576 factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String js onPath, Object json) { 2576 factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String js onPath, Object json) {
2577 if (json == null) { 2577 if (json == null) {
2578 json = {}; 2578 json = {};
2579 } 2579 }
2580 if (json is Map) { 2580 if (json is Map) {
2581 List<String> files; 2581 List<String> files;
2582 if (json.containsKey("files")) { 2582 if (json.containsKey("files")) {
2583 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString); 2583 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString) as List<String>;
2584 } else { 2584 } else {
2585 throw jsonDecoder.missingKey(jsonPath, "files"); 2585 throw jsonDecoder.missingKey(jsonPath, "files");
2586 } 2586 }
2587 return new AnalysisFlushResultsParams(files); 2587 return new AnalysisFlushResultsParams(files);
2588 } else { 2588 } else {
2589 throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params", json) ; 2589 throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params", json) ;
2590 } 2590 }
2591 } 2591 }
2592 2592
2593 factory AnalysisFlushResultsParams.fromNotification(Notification notification) { 2593 factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after
2676 } 2676 }
2677 if (json is Map) { 2677 if (json is Map) {
2678 String file; 2678 String file;
2679 if (json.containsKey("file")) { 2679 if (json.containsKey("file")) {
2680 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 2680 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
2681 } else { 2681 } else {
2682 throw jsonDecoder.missingKey(jsonPath, "file"); 2682 throw jsonDecoder.missingKey(jsonPath, "file");
2683 } 2683 }
2684 List<FoldingRegion> regions; 2684 List<FoldingRegion> regions;
2685 if (json.containsKey("regions")) { 2685 if (json.containsKey("regions")) {
2686 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonP ath, json)); 2686 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonP ath, json)) as List<FoldingRegion>;
2687 } else { 2687 } else {
2688 throw jsonDecoder.missingKey(jsonPath, "regions"); 2688 throw jsonDecoder.missingKey(jsonPath, "regions");
2689 } 2689 }
2690 return new AnalysisFoldingParams(file, regions); 2690 return new AnalysisFoldingParams(file, regions);
2691 } else { 2691 } else {
2692 throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json); 2692 throw jsonDecoder.mismatch(jsonPath, "analysis.folding params", json);
2693 } 2693 }
2694 } 2694 }
2695 2695
2696 factory AnalysisFoldingParams.fromNotification(Notification notification) { 2696 factory AnalysisFoldingParams.fromNotification(Notification notification) {
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after
2790 } 2790 }
2791 if (json is Map) { 2791 if (json is Map) {
2792 String file; 2792 String file;
2793 if (json.containsKey("file")) { 2793 if (json.containsKey("file")) {
2794 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 2794 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
2795 } else { 2795 } else {
2796 throw jsonDecoder.missingKey(jsonPath, "file"); 2796 throw jsonDecoder.missingKey(jsonPath, "file");
2797 } 2797 }
2798 List<HighlightRegion> regions; 2798 List<HighlightRegion> regions;
2799 if (json.containsKey("regions")) { 2799 if (json.containsKey("regions")) {
2800 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jso nPath, json)); 2800 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jso nPath, json)) as List<HighlightRegion>;
2801 } else { 2801 } else {
2802 throw jsonDecoder.missingKey(jsonPath, "regions"); 2802 throw jsonDecoder.missingKey(jsonPath, "regions");
2803 } 2803 }
2804 return new AnalysisHighlightsParams(file, regions); 2804 return new AnalysisHighlightsParams(file, regions);
2805 } else { 2805 } else {
2806 throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json); 2806 throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params", json);
2807 } 2807 }
2808 } 2808 }
2809 2809
2810 factory AnalysisHighlightsParams.fromNotification(Notification notification) { 2810 factory AnalysisHighlightsParams.fromNotification(Notification notification) {
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after
2913 } 2913 }
2914 if (json is Map) { 2914 if (json is Map) {
2915 String file; 2915 String file;
2916 if (json.containsKey("file")) { 2916 if (json.containsKey("file")) {
2917 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 2917 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
2918 } else { 2918 } else {
2919 throw jsonDecoder.missingKey(jsonPath, "file"); 2919 throw jsonDecoder.missingKey(jsonPath, "file");
2920 } 2920 }
2921 List<ImplementedClass> classes; 2921 List<ImplementedClass> classes;
2922 if (json.containsKey("classes")) { 2922 if (json.containsKey("classes")) {
2923 classes = jsonDecoder.decodeList(jsonPath + ".classes", json["classes"], (String jsonPath, Object json) => new ImplementedClass.fromJson(jsonDecoder, js onPath, json)); 2923 classes = jsonDecoder.decodeList(jsonPath + ".classes", json["classes"], (String jsonPath, Object json) => new ImplementedClass.fromJson(jsonDecoder, js onPath, json)) as List<ImplementedClass>;
2924 } else { 2924 } else {
2925 throw jsonDecoder.missingKey(jsonPath, "classes"); 2925 throw jsonDecoder.missingKey(jsonPath, "classes");
2926 } 2926 }
2927 List<ImplementedMember> members; 2927 List<ImplementedMember> members;
2928 if (json.containsKey("members")) { 2928 if (json.containsKey("members")) {
2929 members = jsonDecoder.decodeList(jsonPath + ".members", json["members"], (String jsonPath, Object json) => new ImplementedMember.fromJson(jsonDecoder, j sonPath, json)); 2929 members = jsonDecoder.decodeList(jsonPath + ".members", json["members"], (String jsonPath, Object json) => new ImplementedMember.fromJson(jsonDecoder, j sonPath, json)) as List<ImplementedMember>;
2930 } else { 2930 } else {
2931 throw jsonDecoder.missingKey(jsonPath, "members"); 2931 throw jsonDecoder.missingKey(jsonPath, "members");
2932 } 2932 }
2933 return new AnalysisImplementedParams(file, classes, members); 2933 return new AnalysisImplementedParams(file, classes, members);
2934 } else { 2934 } else {
2935 throw jsonDecoder.mismatch(jsonPath, "analysis.implemented params", json); 2935 throw jsonDecoder.mismatch(jsonPath, "analysis.implemented params", json);
2936 } 2936 }
2937 } 2937 }
2938 2938
2939 factory AnalysisImplementedParams.fromNotification(Notification notification) { 2939 factory AnalysisImplementedParams.fromNotification(Notification notification) {
(...skipping 300 matching lines...) Expand 10 before | Expand all | Expand 10 after
3240 } 3240 }
3241 if (json is Map) { 3241 if (json is Map) {
3242 String file; 3242 String file;
3243 if (json.containsKey("file")) { 3243 if (json.containsKey("file")) {
3244 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 3244 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
3245 } else { 3245 } else {
3246 throw jsonDecoder.missingKey(jsonPath, "file"); 3246 throw jsonDecoder.missingKey(jsonPath, "file");
3247 } 3247 }
3248 List<NavigationRegion> regions; 3248 List<NavigationRegion> regions;
3249 if (json.containsKey("regions")) { 3249 if (json.containsKey("regions")) {
3250 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, js onPath, json)); 3250 regions = jsonDecoder.decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, js onPath, json)) as List<NavigationRegion>;
3251 } else { 3251 } else {
3252 throw jsonDecoder.missingKey(jsonPath, "regions"); 3252 throw jsonDecoder.missingKey(jsonPath, "regions");
3253 } 3253 }
3254 List<NavigationTarget> targets; 3254 List<NavigationTarget> targets;
3255 if (json.containsKey("targets")) { 3255 if (json.containsKey("targets")) {
3256 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, js onPath, json)); 3256 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new NavigationTarget.fromJson(jsonDecoder, js onPath, json)) as List<NavigationTarget>;
3257 } else { 3257 } else {
3258 throw jsonDecoder.missingKey(jsonPath, "targets"); 3258 throw jsonDecoder.missingKey(jsonPath, "targets");
3259 } 3259 }
3260 List<String> files; 3260 List<String> files;
3261 if (json.containsKey("files")) { 3261 if (json.containsKey("files")) {
3262 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString); 3262 files = jsonDecoder.decodeList(jsonPath + ".files", json["files"], jsonD ecoder.decodeString) as List<String>;
3263 } else { 3263 } else {
3264 throw jsonDecoder.missingKey(jsonPath, "files"); 3264 throw jsonDecoder.missingKey(jsonPath, "files");
3265 } 3265 }
3266 return new AnalysisNavigationParams(file, regions, targets, files); 3266 return new AnalysisNavigationParams(file, regions, targets, files);
3267 } else { 3267 } else {
3268 throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json); 3268 throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params", json);
3269 } 3269 }
3270 } 3270 }
3271 3271
3272 factory AnalysisNavigationParams.fromNotification(Notification notification) { 3272 factory AnalysisNavigationParams.fromNotification(Notification notification) {
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after
3364 } 3364 }
3365 if (json is Map) { 3365 if (json is Map) {
3366 String file; 3366 String file;
3367 if (json.containsKey("file")) { 3367 if (json.containsKey("file")) {
3368 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 3368 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
3369 } else { 3369 } else {
3370 throw jsonDecoder.missingKey(jsonPath, "file"); 3370 throw jsonDecoder.missingKey(jsonPath, "file");
3371 } 3371 }
3372 List<Occurrences> occurrences; 3372 List<Occurrences> occurrences;
3373 if (json.containsKey("occurrences")) { 3373 if (json.containsKey("occurrences")) {
3374 occurrences = jsonDecoder.decodeList(jsonPath + ".occurrences", json["oc currences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDeco der, jsonPath, json)); 3374 occurrences = jsonDecoder.decodeList(jsonPath + ".occurrences", json["oc currences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDeco der, jsonPath, json)) as List<Occurrences>;
3375 } else { 3375 } else {
3376 throw jsonDecoder.missingKey(jsonPath, "occurrences"); 3376 throw jsonDecoder.missingKey(jsonPath, "occurrences");
3377 } 3377 }
3378 return new AnalysisOccurrencesParams(file, occurrences); 3378 return new AnalysisOccurrencesParams(file, occurrences);
3379 } else { 3379 } else {
3380 throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json); 3380 throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params", json);
3381 } 3381 }
3382 } 3382 }
3383 3383
3384 factory AnalysisOccurrencesParams.fromNotification(Notification notification) { 3384 factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
(...skipping 250 matching lines...) Expand 10 before | Expand all | Expand 10 after
3635 } 3635 }
3636 if (json is Map) { 3636 if (json is Map) {
3637 String file; 3637 String file;
3638 if (json.containsKey("file")) { 3638 if (json.containsKey("file")) {
3639 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 3639 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
3640 } else { 3640 } else {
3641 throw jsonDecoder.missingKey(jsonPath, "file"); 3641 throw jsonDecoder.missingKey(jsonPath, "file");
3642 } 3642 }
3643 List<Override> overrides; 3643 List<Override> overrides;
3644 if (json.containsKey("overrides")) { 3644 if (json.containsKey("overrides")) {
3645 overrides = jsonDecoder.decodeList(jsonPath + ".overrides", json["overri des"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, json Path, json)); 3645 overrides = jsonDecoder.decodeList(jsonPath + ".overrides", json["overri des"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, json Path, json)) as List<Override>;
3646 } else { 3646 } else {
3647 throw jsonDecoder.missingKey(jsonPath, "overrides"); 3647 throw jsonDecoder.missingKey(jsonPath, "overrides");
3648 } 3648 }
3649 return new AnalysisOverridesParams(file, overrides); 3649 return new AnalysisOverridesParams(file, overrides);
3650 } else { 3650 } else {
3651 throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params", json); 3651 throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params", json);
3652 } 3652 }
3653 } 3653 }
3654 3654
3655 factory AnalysisOverridesParams.fromNotification(Notification notification) { 3655 factory AnalysisOverridesParams.fromNotification(Notification notification) {
(...skipping 354 matching lines...) Expand 10 before | Expand all | Expand 10 after
4010 throw jsonDecoder.missingKey(jsonPath, "replacementOffset"); 4010 throw jsonDecoder.missingKey(jsonPath, "replacementOffset");
4011 } 4011 }
4012 int replacementLength; 4012 int replacementLength;
4013 if (json.containsKey("replacementLength")) { 4013 if (json.containsKey("replacementLength")) {
4014 replacementLength = jsonDecoder.decodeInt(jsonPath + ".replacementLength ", json["replacementLength"]); 4014 replacementLength = jsonDecoder.decodeInt(jsonPath + ".replacementLength ", json["replacementLength"]);
4015 } else { 4015 } else {
4016 throw jsonDecoder.missingKey(jsonPath, "replacementLength"); 4016 throw jsonDecoder.missingKey(jsonPath, "replacementLength");
4017 } 4017 }
4018 List<CompletionSuggestion> results; 4018 List<CompletionSuggestion> results;
4019 if (json.containsKey("results")) { 4019 if (json.containsKey("results")) {
4020 results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder , jsonPath, json)); 4020 results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder , jsonPath, json)) as List<CompletionSuggestion>;
4021 } else { 4021 } else {
4022 throw jsonDecoder.missingKey(jsonPath, "results"); 4022 throw jsonDecoder.missingKey(jsonPath, "results");
4023 } 4023 }
4024 bool isLast; 4024 bool isLast;
4025 if (json.containsKey("isLast")) { 4025 if (json.containsKey("isLast")) {
4026 isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]); 4026 isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]);
4027 } else { 4027 } else {
4028 throw jsonDecoder.missingKey(jsonPath, "isLast"); 4028 throw jsonDecoder.missingKey(jsonPath, "isLast");
4029 } 4029 }
4030 return new CompletionResultsParams(id, replacementOffset, replacementLengt h, results, isLast); 4030 return new CompletionResultsParams(id, replacementOffset, replacementLengt h, results, isLast);
(...skipping 961 matching lines...) Expand 10 before | Expand all | Expand 10 after
4992 this.hierarchyItems = hierarchyItems; 4992 this.hierarchyItems = hierarchyItems;
4993 } 4993 }
4994 4994
4995 factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) { 4995 factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
4996 if (json == null) { 4996 if (json == null) {
4997 json = {}; 4997 json = {};
4998 } 4998 }
4999 if (json is Map) { 4999 if (json is Map) {
5000 List<TypeHierarchyItem> hierarchyItems; 5000 List<TypeHierarchyItem> hierarchyItems;
5001 if (json.containsKey("hierarchyItems")) { 5001 if (json.containsKey("hierarchyItems")) {
5002 hierarchyItems = jsonDecoder.decodeList(jsonPath + ".hierarchyItems", js on["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fr omJson(jsonDecoder, jsonPath, json)); 5002 hierarchyItems = jsonDecoder.decodeList(jsonPath + ".hierarchyItems", js on["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fr omJson(jsonDecoder, jsonPath, json)) as List<TypeHierarchyItem>;
5003 } 5003 }
5004 return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems); 5004 return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
5005 } else { 5005 } else {
5006 throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result", jso n); 5006 throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result", jso n);
5007 } 5007 }
5008 } 5008 }
5009 5009
5010 factory SearchGetTypeHierarchyResult.fromResponse(Response response) { 5010 factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
5011 return new SearchGetTypeHierarchyResult.fromJson( 5011 return new SearchGetTypeHierarchyResult.fromJson(
5012 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), " result", response._result); 5012 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), " result", response._result);
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after
5114 } 5114 }
5115 if (json is Map) { 5115 if (json is Map) {
5116 String id; 5116 String id;
5117 if (json.containsKey("id")) { 5117 if (json.containsKey("id")) {
5118 id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]); 5118 id = jsonDecoder.decodeString(jsonPath + ".id", json["id"]);
5119 } else { 5119 } else {
5120 throw jsonDecoder.missingKey(jsonPath, "id"); 5120 throw jsonDecoder.missingKey(jsonPath, "id");
5121 } 5121 }
5122 List<SearchResult> results; 5122 List<SearchResult> results;
5123 if (json.containsKey("results")) { 5123 if (json.containsKey("results")) {
5124 results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPa th, json)); 5124 results = jsonDecoder.decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPa th, json)) as List<SearchResult>;
5125 } else { 5125 } else {
5126 throw jsonDecoder.missingKey(jsonPath, "results"); 5126 throw jsonDecoder.missingKey(jsonPath, "results");
5127 } 5127 }
5128 bool isLast; 5128 bool isLast;
5129 if (json.containsKey("isLast")) { 5129 if (json.containsKey("isLast")) {
5130 isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]); 5130 isLast = jsonDecoder.decodeBool(jsonPath + ".isLast", json["isLast"]);
5131 } else { 5131 } else {
5132 throw jsonDecoder.missingKey(jsonPath, "isLast"); 5132 throw jsonDecoder.missingKey(jsonPath, "isLast");
5133 } 5133 }
5134 return new SearchResultsParams(id, results, isLast); 5134 return new SearchResultsParams(id, results, isLast);
(...skipping 264 matching lines...) Expand 10 before | Expand all | Expand 10 after
5399 this.selectionLength = selectionLength; 5399 this.selectionLength = selectionLength;
5400 } 5400 }
5401 5401
5402 factory EditFormatResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob ject json) { 5402 factory EditFormatResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Ob ject json) {
5403 if (json == null) { 5403 if (json == null) {
5404 json = {}; 5404 json = {};
5405 } 5405 }
5406 if (json is Map) { 5406 if (json is Map) {
5407 List<SourceEdit> edits; 5407 List<SourceEdit> edits;
5408 if (json.containsKey("edits")) { 5408 if (json.containsKey("edits")) {
5409 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )); 5409 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )) as List<SourceEdit>;
5410 } else { 5410 } else {
5411 throw jsonDecoder.missingKey(jsonPath, "edits"); 5411 throw jsonDecoder.missingKey(jsonPath, "edits");
5412 } 5412 }
5413 int selectionOffset; 5413 int selectionOffset;
5414 if (json.containsKey("selectionOffset")) { 5414 if (json.containsKey("selectionOffset")) {
5415 selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", j son["selectionOffset"]); 5415 selectionOffset = jsonDecoder.decodeInt(jsonPath + ".selectionOffset", j son["selectionOffset"]);
5416 } else { 5416 } else {
5417 throw jsonDecoder.missingKey(jsonPath, "selectionOffset"); 5417 throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
5418 } 5418 }
5419 int selectionLength; 5419 int selectionLength;
(...skipping 209 matching lines...) Expand 10 before | Expand all | Expand 10 after
5629 this.assists = assists; 5629 this.assists = assists;
5630 } 5630 }
5631 5631
5632 factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath , Object json) { 5632 factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath , Object json) {
5633 if (json == null) { 5633 if (json == null) {
5634 json = {}; 5634 json = {};
5635 } 5635 }
5636 if (json is Map) { 5636 if (json is Map) {
5637 List<SourceChange> assists; 5637 List<SourceChange> assists;
5638 if (json.containsKey("assists")) { 5638 if (json.containsKey("assists")) {
5639 assists = jsonDecoder.decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPa th, json)); 5639 assists = jsonDecoder.decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPa th, json)) as List<SourceChange>;
5640 } else { 5640 } else {
5641 throw jsonDecoder.missingKey(jsonPath, "assists"); 5641 throw jsonDecoder.missingKey(jsonPath, "assists");
5642 } 5642 }
5643 return new EditGetAssistsResult(assists); 5643 return new EditGetAssistsResult(assists);
5644 } else { 5644 } else {
5645 throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result", json); 5645 throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result", json);
5646 } 5646 }
5647 } 5647 }
5648 5648
5649 factory EditGetAssistsResult.fromResponse(Response response) { 5649 factory EditGetAssistsResult.fromResponse(Response response) {
(...skipping 191 matching lines...) Expand 10 before | Expand all | Expand 10 after
5841 this.kinds = kinds; 5841 this.kinds = kinds;
5842 } 5842 }
5843 5843
5844 factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, S tring jsonPath, Object json) { 5844 factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, S tring jsonPath, Object json) {
5845 if (json == null) { 5845 if (json == null) {
5846 json = {}; 5846 json = {};
5847 } 5847 }
5848 if (json is Map) { 5848 if (json is Map) {
5849 List<RefactoringKind> kinds; 5849 List<RefactoringKind> kinds;
5850 if (json.containsKey("kinds")) { 5850 if (json.containsKey("kinds")) {
5851 kinds = jsonDecoder.decodeList(jsonPath + ".kinds", json["kinds"], (Stri ng jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json)); 5851 kinds = jsonDecoder.decodeList(jsonPath + ".kinds", json["kinds"], (Stri ng jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json)) as List<RefactoringKind>;
5852 } else { 5852 } else {
5853 throw jsonDecoder.missingKey(jsonPath, "kinds"); 5853 throw jsonDecoder.missingKey(jsonPath, "kinds");
5854 } 5854 }
5855 return new EditGetAvailableRefactoringsResult(kinds); 5855 return new EditGetAvailableRefactoringsResult(kinds);
5856 } else { 5856 } else {
5857 throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result ", json); 5857 throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result ", json);
5858 } 5858 }
5859 } 5859 }
5860 5860
5861 factory EditGetAvailableRefactoringsResult.fromResponse(Response response) { 5861 factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
(...skipping 165 matching lines...) Expand 10 before | Expand all | Expand 10 after
6027 this.fixes = fixes; 6027 this.fixes = fixes;
6028 } 6028 }
6029 6029
6030 factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) { 6030 factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
6031 if (json == null) { 6031 if (json == null) {
6032 json = {}; 6032 json = {};
6033 } 6033 }
6034 if (json is Map) { 6034 if (json is Map) {
6035 List<AnalysisErrorFixes> fixes; 6035 List<AnalysisErrorFixes> fixes;
6036 if (json.containsKey("fixes")) { 6036 if (json.containsKey("fixes")) {
6037 fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (Stri ng jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPa th, json)); 6037 fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (Stri ng jsonPath, Object json) => new AnalysisErrorFixes.fromJson(jsonDecoder, jsonPa th, json)) as List<AnalysisErrorFixes>;
6038 } else { 6038 } else {
6039 throw jsonDecoder.missingKey(jsonPath, "fixes"); 6039 throw jsonDecoder.missingKey(jsonPath, "fixes");
6040 } 6040 }
6041 return new EditGetFixesResult(fixes); 6041 return new EditGetFixesResult(fixes);
6042 } else { 6042 } else {
6043 throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json); 6043 throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result", json);
6044 } 6044 }
6045 } 6045 }
6046 6046
6047 factory EditGetFixesResult.fromResponse(Response response) { 6047 factory EditGetFixesResult.fromResponse(Response response) {
(...skipping 396 matching lines...) Expand 10 before | Expand all | Expand 10 after
6444 this.potentialEdits = potentialEdits; 6444 this.potentialEdits = potentialEdits;
6445 } 6445 }
6446 6446
6447 factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String json Path, Object json) { 6447 factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String json Path, Object json) {
6448 if (json == null) { 6448 if (json == null) {
6449 json = {}; 6449 json = {};
6450 } 6450 }
6451 if (json is Map) { 6451 if (json is Map) {
6452 List<RefactoringProblem> initialProblems; 6452 List<RefactoringProblem> initialProblems;
6453 if (json.containsKey("initialProblems")) { 6453 if (json.containsKey("initialProblems")) {
6454 initialProblems = jsonDecoder.decodeList(jsonPath + ".initialProblems", json["initialProblems"], (String jsonPath, Object json) => new RefactoringProble m.fromJson(jsonDecoder, jsonPath, json)); 6454 initialProblems = jsonDecoder.decodeList(jsonPath + ".initialProblems", json["initialProblems"], (String jsonPath, Object json) => new RefactoringProble m.fromJson(jsonDecoder, jsonPath, json)) as List<RefactoringProblem>;
6455 } else { 6455 } else {
6456 throw jsonDecoder.missingKey(jsonPath, "initialProblems"); 6456 throw jsonDecoder.missingKey(jsonPath, "initialProblems");
6457 } 6457 }
6458 List<RefactoringProblem> optionsProblems; 6458 List<RefactoringProblem> optionsProblems;
6459 if (json.containsKey("optionsProblems")) { 6459 if (json.containsKey("optionsProblems")) {
6460 optionsProblems = jsonDecoder.decodeList(jsonPath + ".optionsProblems", json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProble m.fromJson(jsonDecoder, jsonPath, json)); 6460 optionsProblems = jsonDecoder.decodeList(jsonPath + ".optionsProblems", json["optionsProblems"], (String jsonPath, Object json) => new RefactoringProble m.fromJson(jsonDecoder, jsonPath, json)) as List<RefactoringProblem>;
6461 } else { 6461 } else {
6462 throw jsonDecoder.missingKey(jsonPath, "optionsProblems"); 6462 throw jsonDecoder.missingKey(jsonPath, "optionsProblems");
6463 } 6463 }
6464 List<RefactoringProblem> finalProblems; 6464 List<RefactoringProblem> finalProblems;
6465 if (json.containsKey("finalProblems")) { 6465 if (json.containsKey("finalProblems")) {
6466 finalProblems = jsonDecoder.decodeList(jsonPath + ".finalProblems", json ["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.from Json(jsonDecoder, jsonPath, json)); 6466 finalProblems = jsonDecoder.decodeList(jsonPath + ".finalProblems", json ["finalProblems"], (String jsonPath, Object json) => new RefactoringProblem.from Json(jsonDecoder, jsonPath, json)) as List<RefactoringProblem>;
6467 } else { 6467 } else {
6468 throw jsonDecoder.missingKey(jsonPath, "finalProblems"); 6468 throw jsonDecoder.missingKey(jsonPath, "finalProblems");
6469 } 6469 }
6470 RefactoringFeedback feedback; 6470 RefactoringFeedback feedback;
6471 if (json.containsKey("feedback")) { 6471 if (json.containsKey("feedback")) {
6472 feedback = new RefactoringFeedback.fromJson(jsonDecoder, jsonPath + ".fe edback", json["feedback"], json); 6472 feedback = new RefactoringFeedback.fromJson(jsonDecoder, jsonPath + ".fe edback", json["feedback"], json);
6473 } 6473 }
6474 SourceChange change; 6474 SourceChange change;
6475 if (json.containsKey("change")) { 6475 if (json.containsKey("change")) {
6476 change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", js on["change"]); 6476 change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", js on["change"]);
6477 } 6477 }
6478 List<String> potentialEdits; 6478 List<String> potentialEdits;
6479 if (json.containsKey("potentialEdits")) { 6479 if (json.containsKey("potentialEdits")) {
6480 potentialEdits = jsonDecoder.decodeList(jsonPath + ".potentialEdits", js on["potentialEdits"], jsonDecoder.decodeString); 6480 potentialEdits = jsonDecoder.decodeList(jsonPath + ".potentialEdits", js on["potentialEdits"], jsonDecoder.decodeString) as List<String>;
6481 } 6481 }
6482 return new EditGetRefactoringResult(initialProblems, optionsProblems, fina lProblems, feedback: feedback, change: change, potentialEdits: potentialEdits); 6482 return new EditGetRefactoringResult(initialProblems, optionsProblems, fina lProblems, feedback: feedback, change: change, potentialEdits: potentialEdits);
6483 } else { 6483 } else {
6484 throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json); 6484 throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result", json);
6485 } 6485 }
6486 } 6486 }
6487 6487
6488 factory EditGetRefactoringResult.fromResponse(Response response) { 6488 factory EditGetRefactoringResult.fromResponse(Response response) {
6489 return new EditGetRefactoringResult.fromJson( 6489 return new EditGetRefactoringResult.fromJson(
6490 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), " result", response._result); 6490 new ResponseDecoder(REQUEST_ID_REFACTORING_KINDS.remove(response.id)), " result", response._result);
(...skipping 905 matching lines...) Expand 10 before | Expand all | Expand 10 after
7396 this.subscriptions = subscriptions; 7396 this.subscriptions = subscriptions;
7397 } 7397 }
7398 7398
7399 factory ExecutionSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Stri ng jsonPath, Object json) { 7399 factory ExecutionSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, Stri ng jsonPath, Object json) {
7400 if (json == null) { 7400 if (json == null) {
7401 json = {}; 7401 json = {};
7402 } 7402 }
7403 if (json is Map) { 7403 if (json is Map) {
7404 List<ExecutionService> subscriptions; 7404 List<ExecutionService> subscriptions;
7405 if (json.containsKey("subscriptions")) { 7405 if (json.containsKey("subscriptions")) {
7406 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJs on(jsonDecoder, jsonPath, json)); 7406 subscriptions = jsonDecoder.decodeList(jsonPath + ".subscriptions", json ["subscriptions"], (String jsonPath, Object json) => new ExecutionService.fromJs on(jsonDecoder, jsonPath, json)) as List<ExecutionService>;
7407 } else { 7407 } else {
7408 throw jsonDecoder.missingKey(jsonPath, "subscriptions"); 7408 throw jsonDecoder.missingKey(jsonPath, "subscriptions");
7409 } 7409 }
7410 return new ExecutionSetSubscriptionsParams(subscriptions); 7410 return new ExecutionSetSubscriptionsParams(subscriptions);
7411 } else { 7411 } else {
7412 throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params", json); 7412 throw jsonDecoder.mismatch(jsonPath, "execution.setSubscriptions params", json);
7413 } 7413 }
7414 } 7414 }
7415 7415
7416 factory ExecutionSetSubscriptionsParams.fromRequest(Request request) { 7416 factory ExecutionSetSubscriptionsParams.fromRequest(Request request) {
(...skipping 130 matching lines...) Expand 10 before | Expand all | Expand 10 after
7547 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]); 7547 file = jsonDecoder.decodeString(jsonPath + ".file", json["file"]);
7548 } else { 7548 } else {
7549 throw jsonDecoder.missingKey(jsonPath, "file"); 7549 throw jsonDecoder.missingKey(jsonPath, "file");
7550 } 7550 }
7551 ExecutableKind kind; 7551 ExecutableKind kind;
7552 if (json.containsKey("kind")) { 7552 if (json.containsKey("kind")) {
7553 kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json ["kind"]); 7553 kind = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".kind", json ["kind"]);
7554 } 7554 }
7555 List<String> referencedFiles; 7555 List<String> referencedFiles;
7556 if (json.containsKey("referencedFiles")) { 7556 if (json.containsKey("referencedFiles")) {
7557 referencedFiles = jsonDecoder.decodeList(jsonPath + ".referencedFiles", json["referencedFiles"], jsonDecoder.decodeString); 7557 referencedFiles = jsonDecoder.decodeList(jsonPath + ".referencedFiles", json["referencedFiles"], jsonDecoder.decodeString) as List<String>;
7558 } 7558 }
7559 return new ExecutionLaunchDataParams(file, kind: kind, referencedFiles: re ferencedFiles); 7559 return new ExecutionLaunchDataParams(file, kind: kind, referencedFiles: re ferencedFiles);
7560 } else { 7560 } else {
7561 throw jsonDecoder.mismatch(jsonPath, "execution.launchData params", json); 7561 throw jsonDecoder.mismatch(jsonPath, "execution.launchData params", json);
7562 } 7562 }
7563 } 7563 }
7564 7564
7565 factory ExecutionLaunchDataParams.fromNotification(Notification notification) { 7565 factory ExecutionLaunchDataParams.fromNotification(Notification notification) {
7566 return new ExecutionLaunchDataParams.fromJson( 7566 return new ExecutionLaunchDataParams.fromJson(
7567 new ResponseDecoder(null), "params", notification._params); 7567 new ResponseDecoder(null), "params", notification._params);
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after
7658 this.contexts = contexts; 7658 this.contexts = contexts;
7659 } 7659 }
7660 7660
7661 factory DiagnosticGetDiagnosticsResult.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) { 7661 factory DiagnosticGetDiagnosticsResult.fromJson(JsonDecoder jsonDecoder, Strin g jsonPath, Object json) {
7662 if (json == null) { 7662 if (json == null) {
7663 json = {}; 7663 json = {};
7664 } 7664 }
7665 if (json is Map) { 7665 if (json is Map) {
7666 List<ContextData> contexts; 7666 List<ContextData> contexts;
7667 if (json.containsKey("contexts")) { 7667 if (json.containsKey("contexts")) {
7668 contexts = jsonDecoder.decodeList(jsonPath + ".contexts", json["contexts "], (String jsonPath, Object json) => new ContextData.fromJson(jsonDecoder, json Path, json)); 7668 contexts = jsonDecoder.decodeList(jsonPath + ".contexts", json["contexts "], (String jsonPath, Object json) => new ContextData.fromJson(jsonDecoder, json Path, json)) as List<ContextData>;
7669 } else { 7669 } else {
7670 throw jsonDecoder.missingKey(jsonPath, "contexts"); 7670 throw jsonDecoder.missingKey(jsonPath, "contexts");
7671 } 7671 }
7672 return new DiagnosticGetDiagnosticsResult(contexts); 7672 return new DiagnosticGetDiagnosticsResult(contexts);
7673 } else { 7673 } else {
7674 throw jsonDecoder.mismatch(jsonPath, "diagnostic.getDiagnostics result", j son); 7674 throw jsonDecoder.mismatch(jsonPath, "diagnostic.getDiagnostics result", j son);
7675 } 7675 }
7676 } 7676 }
7677 7677
7678 factory DiagnosticGetDiagnosticsResult.fromResponse(Response response) { 7678 factory DiagnosticGetDiagnosticsResult.fromResponse(Response response) {
(...skipping 408 matching lines...) Expand 10 before | Expand all | Expand 10 after
8087 } 8087 }
8088 if (json is Map) { 8088 if (json is Map) {
8089 AnalysisError error; 8089 AnalysisError error;
8090 if (json.containsKey("error")) { 8090 if (json.containsKey("error")) {
8091 error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", jso n["error"]); 8091 error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", jso n["error"]);
8092 } else { 8092 } else {
8093 throw jsonDecoder.missingKey(jsonPath, "error"); 8093 throw jsonDecoder.missingKey(jsonPath, "error");
8094 } 8094 }
8095 List<SourceChange> fixes; 8095 List<SourceChange> fixes;
8096 if (json.containsKey("fixes")) { 8096 if (json.containsKey("fixes")) {
8097 fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (Stri ng jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, js on)); 8097 fixes = jsonDecoder.decodeList(jsonPath + ".fixes", json["fixes"], (Stri ng jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, js on)) as List<SourceChange>;
8098 } else { 8098 } else {
8099 throw jsonDecoder.missingKey(jsonPath, "fixes"); 8099 throw jsonDecoder.missingKey(jsonPath, "fixes");
8100 } 8100 }
8101 return new AnalysisErrorFixes(error, fixes: fixes); 8101 return new AnalysisErrorFixes(error, fixes: fixes);
8102 } else { 8102 } else {
8103 throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json); 8103 throw jsonDecoder.mismatch(jsonPath, "AnalysisErrorFixes", json);
8104 } 8104 }
8105 } 8105 }
8106 8106
8107 Map<String, dynamic> toJson() { 8107 Map<String, dynamic> toJson() {
(...skipping 650 matching lines...) Expand 10 before | Expand all | Expand 10 after
8758 factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath , Object json) { 8758 factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath , Object json) {
8759 if (json == null) { 8759 if (json == null) {
8760 json = {}; 8760 json = {};
8761 } 8761 }
8762 if (json is Map) { 8762 if (json is Map) {
8763 if (json["type"] != "change") { 8763 if (json["type"] != "change") {
8764 throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json); 8764 throw jsonDecoder.mismatch(jsonPath, "equal " + "change", json);
8765 } 8765 }
8766 List<SourceEdit> edits; 8766 List<SourceEdit> edits;
8767 if (json.containsKey("edits")) { 8767 if (json.containsKey("edits")) {
8768 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )); 8768 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )) as List<SourceEdit>;
8769 } else { 8769 } else {
8770 throw jsonDecoder.missingKey(jsonPath, "edits"); 8770 throw jsonDecoder.missingKey(jsonPath, "edits");
8771 } 8771 }
8772 return new ChangeContentOverlay(edits); 8772 return new ChangeContentOverlay(edits);
8773 } else { 8773 } else {
8774 throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json); 8774 throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay", json);
8775 } 8775 }
8776 } 8776 }
8777 8777
8778 Map<String, dynamic> toJson() { 8778 Map<String, dynamic> toJson() {
(...skipping 450 matching lines...) Expand 10 before | Expand all | Expand 10 after
9229 Element element; 9229 Element element;
9230 if (json.containsKey("element")) { 9230 if (json.containsKey("element")) {
9231 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[ "element"]); 9231 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[ "element"]);
9232 } 9232 }
9233 String returnType; 9233 String returnType;
9234 if (json.containsKey("returnType")) { 9234 if (json.containsKey("returnType")) {
9235 returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["re turnType"]); 9235 returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["re turnType"]);
9236 } 9236 }
9237 List<String> parameterNames; 9237 List<String> parameterNames;
9238 if (json.containsKey("parameterNames")) { 9238 if (json.containsKey("parameterNames")) {
9239 parameterNames = jsonDecoder.decodeList(jsonPath + ".parameterNames", js on["parameterNames"], jsonDecoder.decodeString); 9239 parameterNames = jsonDecoder.decodeList(jsonPath + ".parameterNames", js on["parameterNames"], jsonDecoder.decodeString) as List<String>;
9240 } 9240 }
9241 List<String> parameterTypes; 9241 List<String> parameterTypes;
9242 if (json.containsKey("parameterTypes")) { 9242 if (json.containsKey("parameterTypes")) {
9243 parameterTypes = jsonDecoder.decodeList(jsonPath + ".parameterTypes", js on["parameterTypes"], jsonDecoder.decodeString); 9243 parameterTypes = jsonDecoder.decodeList(jsonPath + ".parameterTypes", js on["parameterTypes"], jsonDecoder.decodeString) as List<String>;
9244 } 9244 }
9245 int requiredParameterCount; 9245 int requiredParameterCount;
9246 if (json.containsKey("requiredParameterCount")) { 9246 if (json.containsKey("requiredParameterCount")) {
9247 requiredParameterCount = jsonDecoder.decodeInt(jsonPath + ".requiredPara meterCount", json["requiredParameterCount"]); 9247 requiredParameterCount = jsonDecoder.decodeInt(jsonPath + ".requiredPara meterCount", json["requiredParameterCount"]);
9248 } 9248 }
9249 bool hasNamedParameters; 9249 bool hasNamedParameters;
9250 if (json.containsKey("hasNamedParameters")) { 9250 if (json.containsKey("hasNamedParameters")) {
9251 hasNamedParameters = jsonDecoder.decodeBool(jsonPath + ".hasNamedParamet ers", json["hasNamedParameters"]); 9251 hasNamedParameters = jsonDecoder.decodeBool(jsonPath + ".hasNamedParamet ers", json["hasNamedParameters"]);
9252 } 9252 }
9253 String parameterName; 9253 String parameterName;
(...skipping 346 matching lines...) Expand 10 before | Expand all | Expand 10 after
9600 throw jsonDecoder.missingKey(jsonPath, "implicitFileCount"); 9600 throw jsonDecoder.missingKey(jsonPath, "implicitFileCount");
9601 } 9601 }
9602 int workItemQueueLength; 9602 int workItemQueueLength;
9603 if (json.containsKey("workItemQueueLength")) { 9603 if (json.containsKey("workItemQueueLength")) {
9604 workItemQueueLength = jsonDecoder.decodeInt(jsonPath + ".workItemQueueLe ngth", json["workItemQueueLength"]); 9604 workItemQueueLength = jsonDecoder.decodeInt(jsonPath + ".workItemQueueLe ngth", json["workItemQueueLength"]);
9605 } else { 9605 } else {
9606 throw jsonDecoder.missingKey(jsonPath, "workItemQueueLength"); 9606 throw jsonDecoder.missingKey(jsonPath, "workItemQueueLength");
9607 } 9607 }
9608 List<String> cacheEntryExceptions; 9608 List<String> cacheEntryExceptions;
9609 if (json.containsKey("cacheEntryExceptions")) { 9609 if (json.containsKey("cacheEntryExceptions")) {
9610 cacheEntryExceptions = jsonDecoder.decodeList(jsonPath + ".cacheEntryExc eptions", json["cacheEntryExceptions"], jsonDecoder.decodeString); 9610 cacheEntryExceptions = jsonDecoder.decodeList(jsonPath + ".cacheEntryExc eptions", json["cacheEntryExceptions"], jsonDecoder.decodeString) as List<String >;
9611 } else { 9611 } else {
9612 throw jsonDecoder.missingKey(jsonPath, "cacheEntryExceptions"); 9612 throw jsonDecoder.missingKey(jsonPath, "cacheEntryExceptions");
9613 } 9613 }
9614 return new ContextData(name, explicitFileCount, implicitFileCount, workIte mQueueLength, cacheEntryExceptions); 9614 return new ContextData(name, explicitFileCount, implicitFileCount, workIte mQueueLength, cacheEntryExceptions);
9615 } else { 9615 } else {
9616 throw jsonDecoder.mismatch(jsonPath, "ContextData", json); 9616 throw jsonDecoder.mismatch(jsonPath, "ContextData", json);
9617 } 9617 }
9618 } 9618 }
9619 9619
9620 Map<String, dynamic> toJson() { 9620 Map<String, dynamic> toJson() {
(...skipping 2258 matching lines...) Expand 10 before | Expand all | Expand 10 after
11879 this.suggestions = suggestions; 11879 this.suggestions = suggestions;
11880 } 11880 }
11881 11881
11882 factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj ect json) { 11882 factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Obj ect json) {
11883 if (json == null) { 11883 if (json == null) {
11884 json = {}; 11884 json = {};
11885 } 11885 }
11886 if (json is Map) { 11886 if (json is Map) {
11887 List<Position> positions; 11887 List<Position> positions;
11888 if (json.containsKey("positions")) { 11888 if (json.containsKey("positions")) {
11889 positions = jsonDecoder.decodeList(jsonPath + ".positions", json["positi ons"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, json Path, json)); 11889 positions = jsonDecoder.decodeList(jsonPath + ".positions", json["positi ons"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, json Path, json)) as List<Position>;
11890 } else { 11890 } else {
11891 throw jsonDecoder.missingKey(jsonPath, "positions"); 11891 throw jsonDecoder.missingKey(jsonPath, "positions");
11892 } 11892 }
11893 int length; 11893 int length;
11894 if (json.containsKey("length")) { 11894 if (json.containsKey("length")) {
11895 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]); 11895 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
11896 } else { 11896 } else {
11897 throw jsonDecoder.missingKey(jsonPath, "length"); 11897 throw jsonDecoder.missingKey(jsonPath, "length");
11898 } 11898 }
11899 List<LinkedEditSuggestion> suggestions; 11899 List<LinkedEditSuggestion> suggestions;
11900 if (json.containsKey("suggestions")) { 11900 if (json.containsKey("suggestions")) {
11901 suggestions = jsonDecoder.decodeList(jsonPath + ".suggestions", json["su ggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson (jsonDecoder, jsonPath, json)); 11901 suggestions = jsonDecoder.decodeList(jsonPath + ".suggestions", json["su ggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson (jsonDecoder, jsonPath, json)) as List<LinkedEditSuggestion>;
11902 } else { 11902 } else {
11903 throw jsonDecoder.missingKey(jsonPath, "suggestions"); 11903 throw jsonDecoder.missingKey(jsonPath, "suggestions");
11904 } 11904 }
11905 return new LinkedEditGroup(positions, length, suggestions); 11905 return new LinkedEditGroup(positions, length, suggestions);
11906 } else { 11906 } else {
11907 throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json); 11907 throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup", json);
11908 } 11908 }
11909 } 11909 }
11910 11910
11911 /** 11911 /**
(...skipping 463 matching lines...) Expand 10 before | Expand all | Expand 10 after
12375 throw jsonDecoder.missingKey(jsonPath, "offset"); 12375 throw jsonDecoder.missingKey(jsonPath, "offset");
12376 } 12376 }
12377 int length; 12377 int length;
12378 if (json.containsKey("length")) { 12378 if (json.containsKey("length")) {
12379 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]); 12379 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
12380 } else { 12380 } else {
12381 throw jsonDecoder.missingKey(jsonPath, "length"); 12381 throw jsonDecoder.missingKey(jsonPath, "length");
12382 } 12382 }
12383 List<int> targets; 12383 List<int> targets;
12384 if (json.containsKey("targets")) { 12384 if (json.containsKey("targets")) {
12385 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], jsonDecoder.decodeInt); 12385 targets = jsonDecoder.decodeList(jsonPath + ".targets", json["targets"], jsonDecoder.decodeInt) as List<int>;
12386 } else { 12386 } else {
12387 throw jsonDecoder.missingKey(jsonPath, "targets"); 12387 throw jsonDecoder.missingKey(jsonPath, "targets");
12388 } 12388 }
12389 return new NavigationRegion(offset, length, targets); 12389 return new NavigationRegion(offset, length, targets);
12390 } else { 12390 } else {
12391 throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json); 12391 throw jsonDecoder.mismatch(jsonPath, "NavigationRegion", json);
12392 } 12392 }
12393 } 12393 }
12394 12394
12395 Map<String, dynamic> toJson() { 12395 Map<String, dynamic> toJson() {
(...skipping 303 matching lines...) Expand 10 before | Expand all | Expand 10 after
12699 } 12699 }
12700 if (json is Map) { 12700 if (json is Map) {
12701 Element element; 12701 Element element;
12702 if (json.containsKey("element")) { 12702 if (json.containsKey("element")) {
12703 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[ "element"]); 12703 element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json[ "element"]);
12704 } else { 12704 } else {
12705 throw jsonDecoder.missingKey(jsonPath, "element"); 12705 throw jsonDecoder.missingKey(jsonPath, "element");
12706 } 12706 }
12707 List<int> offsets; 12707 List<int> offsets;
12708 if (json.containsKey("offsets")) { 12708 if (json.containsKey("offsets")) {
12709 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt); 12709 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt) as List<int>;
12710 } else { 12710 } else {
12711 throw jsonDecoder.missingKey(jsonPath, "offsets"); 12711 throw jsonDecoder.missingKey(jsonPath, "offsets");
12712 } 12712 }
12713 int length; 12713 int length;
12714 if (json.containsKey("length")) { 12714 if (json.containsKey("length")) {
12715 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]); 12715 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
12716 } else { 12716 } else {
12717 throw jsonDecoder.missingKey(jsonPath, "length"); 12717 throw jsonDecoder.missingKey(jsonPath, "length");
12718 } 12718 }
12719 return new Occurrences(element, offsets, length); 12719 return new Occurrences(element, offsets, length);
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after
12858 throw jsonDecoder.missingKey(jsonPath, "offset"); 12858 throw jsonDecoder.missingKey(jsonPath, "offset");
12859 } 12859 }
12860 int length; 12860 int length;
12861 if (json.containsKey("length")) { 12861 if (json.containsKey("length")) {
12862 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]); 12862 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
12863 } else { 12863 } else {
12864 throw jsonDecoder.missingKey(jsonPath, "length"); 12864 throw jsonDecoder.missingKey(jsonPath, "length");
12865 } 12865 }
12866 List<Outline> children; 12866 List<Outline> children;
12867 if (json.containsKey("children")) { 12867 if (json.containsKey("children")) {
12868 children = jsonDecoder.decodeList(jsonPath + ".children", json["children "], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath , json)); 12868 children = jsonDecoder.decodeList(jsonPath + ".children", json["children "], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath , json)) as List<Outline>;
12869 } 12869 }
12870 return new Outline(element, offset, length, children: children); 12870 return new Outline(element, offset, length, children: children);
12871 } else { 12871 } else {
12872 throw jsonDecoder.mismatch(jsonPath, "Outline", json); 12872 throw jsonDecoder.mismatch(jsonPath, "Outline", json);
12873 } 12873 }
12874 } 12874 }
12875 12875
12876 Map<String, dynamic> toJson() { 12876 Map<String, dynamic> toJson() {
12877 Map<String, dynamic> result = {}; 12877 Map<String, dynamic> result = {};
12878 result["element"] = element.toJson(); 12878 result["element"] = element.toJson();
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
13011 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]); 13011 length = jsonDecoder.decodeInt(jsonPath + ".length", json["length"]);
13012 } else { 13012 } else {
13013 throw jsonDecoder.missingKey(jsonPath, "length"); 13013 throw jsonDecoder.missingKey(jsonPath, "length");
13014 } 13014 }
13015 OverriddenMember superclassMember; 13015 OverriddenMember superclassMember;
13016 if (json.containsKey("superclassMember")) { 13016 if (json.containsKey("superclassMember")) {
13017 superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath + ".superclassMember", json["superclassMember"]); 13017 superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath + ".superclassMember", json["superclassMember"]);
13018 } 13018 }
13019 List<OverriddenMember> interfaceMembers; 13019 List<OverriddenMember> interfaceMembers;
13020 if (json.containsKey("interfaceMembers")) { 13020 if (json.containsKey("interfaceMembers")) {
13021 interfaceMembers = jsonDecoder.decodeList(jsonPath + ".interfaceMembers" , json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMemb er.fromJson(jsonDecoder, jsonPath, json)); 13021 interfaceMembers = jsonDecoder.decodeList(jsonPath + ".interfaceMembers" , json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMemb er.fromJson(jsonDecoder, jsonPath, json)) as List<OverriddenMember>;
13022 } 13022 }
13023 return new Override(offset, length, superclassMember: superclassMember, in terfaceMembers: interfaceMembers); 13023 return new Override(offset, length, superclassMember: superclassMember, in terfaceMembers: interfaceMembers);
13024 } else { 13024 } else {
13025 throw jsonDecoder.mismatch(jsonPath, "Override", json); 13025 throw jsonDecoder.mismatch(jsonPath, "Override", json);
13026 } 13026 }
13027 } 13027 }
13028 13028
13029 Map<String, dynamic> toJson() { 13029 Map<String, dynamic> toJson() {
13030 Map<String, dynamic> result = {}; 13030 Map<String, dynamic> result = {};
13031 result["offset"] = offset; 13031 result["offset"] = offset;
(...skipping 1438 matching lines...) Expand 10 before | Expand all | Expand 10 after
14470 throw jsonDecoder.missingKey(jsonPath, "kind"); 14470 throw jsonDecoder.missingKey(jsonPath, "kind");
14471 } 14471 }
14472 bool isPotential; 14472 bool isPotential;
14473 if (json.containsKey("isPotential")) { 14473 if (json.containsKey("isPotential")) {
14474 isPotential = jsonDecoder.decodeBool(jsonPath + ".isPotential", json["is Potential"]); 14474 isPotential = jsonDecoder.decodeBool(jsonPath + ".isPotential", json["is Potential"]);
14475 } else { 14475 } else {
14476 throw jsonDecoder.missingKey(jsonPath, "isPotential"); 14476 throw jsonDecoder.missingKey(jsonPath, "isPotential");
14477 } 14477 }
14478 List<Element> path; 14478 List<Element> path;
14479 if (json.containsKey("path")) { 14479 if (json.containsKey("path")) {
14480 path = jsonDecoder.decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json)); 14480 path = jsonDecoder.decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json)) as List<Element>;
14481 } else { 14481 } else {
14482 throw jsonDecoder.missingKey(jsonPath, "path"); 14482 throw jsonDecoder.missingKey(jsonPath, "path");
14483 } 14483 }
14484 return new SearchResult(location, kind, isPotential, path); 14484 return new SearchResult(location, kind, isPotential, path);
14485 } else { 14485 } else {
14486 throw jsonDecoder.mismatch(jsonPath, "SearchResult", json); 14486 throw jsonDecoder.mismatch(jsonPath, "SearchResult", json);
14487 } 14487 }
14488 } 14488 }
14489 14489
14490 Map<String, dynamic> toJson() { 14490 Map<String, dynamic> toJson() {
(...skipping 269 matching lines...) Expand 10 before | Expand all | Expand 10 after
14760 } 14760 }
14761 if (json is Map) { 14761 if (json is Map) {
14762 String message; 14762 String message;
14763 if (json.containsKey("message")) { 14763 if (json.containsKey("message")) {
14764 message = jsonDecoder.decodeString(jsonPath + ".message", json["message" ]); 14764 message = jsonDecoder.decodeString(jsonPath + ".message", json["message" ]);
14765 } else { 14765 } else {
14766 throw jsonDecoder.missingKey(jsonPath, "message"); 14766 throw jsonDecoder.missingKey(jsonPath, "message");
14767 } 14767 }
14768 List<SourceFileEdit> edits; 14768 List<SourceFileEdit> edits;
14769 if (json.containsKey("edits")) { 14769 if (json.containsKey("edits")) {
14770 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json)); 14770 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json)) as List<SourceFileEdit>;
14771 } else { 14771 } else {
14772 throw jsonDecoder.missingKey(jsonPath, "edits"); 14772 throw jsonDecoder.missingKey(jsonPath, "edits");
14773 } 14773 }
14774 List<LinkedEditGroup> linkedEditGroups; 14774 List<LinkedEditGroup> linkedEditGroups;
14775 if (json.containsKey("linkedEditGroups")) { 14775 if (json.containsKey("linkedEditGroups")) {
14776 linkedEditGroups = jsonDecoder.decodeList(jsonPath + ".linkedEditGroups" , json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGrou p.fromJson(jsonDecoder, jsonPath, json)); 14776 linkedEditGroups = jsonDecoder.decodeList(jsonPath + ".linkedEditGroups" , json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGrou p.fromJson(jsonDecoder, jsonPath, json)) as List<LinkedEditGroup>;
14777 } else { 14777 } else {
14778 throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups"); 14778 throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups");
14779 } 14779 }
14780 Position selection; 14780 Position selection;
14781 if (json.containsKey("selection")) { 14781 if (json.containsKey("selection")) {
14782 selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]); 14782 selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
14783 } 14783 }
14784 return new SourceChange(message, edits: edits, linkedEditGroups: linkedEdi tGroups, selection: selection); 14784 return new SourceChange(message, edits: edits, linkedEditGroups: linkedEdi tGroups, selection: selection);
14785 } else { 14785 } else {
14786 throw jsonDecoder.mismatch(jsonPath, "SourceChange", json); 14786 throw jsonDecoder.mismatch(jsonPath, "SourceChange", json);
(...skipping 328 matching lines...) Expand 10 before | Expand all | Expand 10 after
15115 throw jsonDecoder.missingKey(jsonPath, "file"); 15115 throw jsonDecoder.missingKey(jsonPath, "file");
15116 } 15116 }
15117 int fileStamp; 15117 int fileStamp;
15118 if (json.containsKey("fileStamp")) { 15118 if (json.containsKey("fileStamp")) {
15119 fileStamp = jsonDecoder.decodeInt(jsonPath + ".fileStamp", json["fileSta mp"]); 15119 fileStamp = jsonDecoder.decodeInt(jsonPath + ".fileStamp", json["fileSta mp"]);
15120 } else { 15120 } else {
15121 throw jsonDecoder.missingKey(jsonPath, "fileStamp"); 15121 throw jsonDecoder.missingKey(jsonPath, "fileStamp");
15122 } 15122 }
15123 List<SourceEdit> edits; 15123 List<SourceEdit> edits;
15124 if (json.containsKey("edits")) { 15124 if (json.containsKey("edits")) {
15125 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )); 15125 edits = jsonDecoder.decodeList(jsonPath + ".edits", json["edits"], (Stri ng jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json )) as List<SourceEdit>;
15126 } else { 15126 } else {
15127 throw jsonDecoder.missingKey(jsonPath, "edits"); 15127 throw jsonDecoder.missingKey(jsonPath, "edits");
15128 } 15128 }
15129 return new SourceFileEdit(file, fileStamp, edits: edits); 15129 return new SourceFileEdit(file, fileStamp, edits: edits);
15130 } else { 15130 } else {
15131 throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json); 15131 throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit", json);
15132 } 15132 }
15133 } 15133 }
15134 15134
15135 Map<String, dynamic> toJson() { 15135 Map<String, dynamic> toJson() {
(...skipping 218 matching lines...) Expand 10 before | Expand all | Expand 10 after
15354 Element memberElement; 15354 Element memberElement;
15355 if (json.containsKey("memberElement")) { 15355 if (json.containsKey("memberElement")) {
15356 memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberEle ment", json["memberElement"]); 15356 memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberEle ment", json["memberElement"]);
15357 } 15357 }
15358 int superclass; 15358 int superclass;
15359 if (json.containsKey("superclass")) { 15359 if (json.containsKey("superclass")) {
15360 superclass = jsonDecoder.decodeInt(jsonPath + ".superclass", json["super class"]); 15360 superclass = jsonDecoder.decodeInt(jsonPath + ".superclass", json["super class"]);
15361 } 15361 }
15362 List<int> interfaces; 15362 List<int> interfaces;
15363 if (json.containsKey("interfaces")) { 15363 if (json.containsKey("interfaces")) {
15364 interfaces = jsonDecoder.decodeList(jsonPath + ".interfaces", json["inte rfaces"], jsonDecoder.decodeInt); 15364 interfaces = jsonDecoder.decodeList(jsonPath + ".interfaces", json["inte rfaces"], jsonDecoder.decodeInt) as List<int>;
15365 } else { 15365 } else {
15366 throw jsonDecoder.missingKey(jsonPath, "interfaces"); 15366 throw jsonDecoder.missingKey(jsonPath, "interfaces");
15367 } 15367 }
15368 List<int> mixins; 15368 List<int> mixins;
15369 if (json.containsKey("mixins")) { 15369 if (json.containsKey("mixins")) {
15370 mixins = jsonDecoder.decodeList(jsonPath + ".mixins", json["mixins"], js onDecoder.decodeInt); 15370 mixins = jsonDecoder.decodeList(jsonPath + ".mixins", json["mixins"], js onDecoder.decodeInt) as List<int>;
15371 } else { 15371 } else {
15372 throw jsonDecoder.missingKey(jsonPath, "mixins"); 15372 throw jsonDecoder.missingKey(jsonPath, "mixins");
15373 } 15373 }
15374 List<int> subclasses; 15374 List<int> subclasses;
15375 if (json.containsKey("subclasses")) { 15375 if (json.containsKey("subclasses")) {
15376 subclasses = jsonDecoder.decodeList(jsonPath + ".subclasses", json["subc lasses"], jsonDecoder.decodeInt); 15376 subclasses = jsonDecoder.decodeList(jsonPath + ".subclasses", json["subc lasses"], jsonDecoder.decodeInt) as List<int>;
15377 } else { 15377 } else {
15378 throw jsonDecoder.missingKey(jsonPath, "subclasses"); 15378 throw jsonDecoder.missingKey(jsonPath, "subclasses");
15379 } 15379 }
15380 return new TypeHierarchyItem(classElement, displayName: displayName, membe rElement: memberElement, superclass: superclass, interfaces: interfaces, mixins: mixins, subclasses: subclasses); 15380 return new TypeHierarchyItem(classElement, displayName: displayName, membe rElement: memberElement, superclass: superclass, interfaces: interfaces, mixins: mixins, subclasses: subclasses);
15381 } else { 15381 } else {
15382 throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem", json); 15382 throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem", json);
15383 } 15383 }
15384 } 15384 }
15385 15385
15386 Map<String, dynamic> toJson() { 15386 Map<String, dynamic> toJson() {
(...skipping 228 matching lines...) Expand 10 before | Expand all | Expand 10 after
15615 this.lengths = lengths; 15615 this.lengths = lengths;
15616 } 15616 }
15617 15617
15618 factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) { 15618 factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
15619 if (json == null) { 15619 if (json == null) {
15620 json = {}; 15620 json = {};
15621 } 15621 }
15622 if (json is Map) { 15622 if (json is Map) {
15623 List<int> coveringExpressionOffsets; 15623 List<int> coveringExpressionOffsets;
15624 if (json.containsKey("coveringExpressionOffsets")) { 15624 if (json.containsKey("coveringExpressionOffsets")) {
15625 coveringExpressionOffsets = jsonDecoder.decodeList(jsonPath + ".covering ExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder.decodeInt); 15625 coveringExpressionOffsets = jsonDecoder.decodeList(jsonPath + ".covering ExpressionOffsets", json["coveringExpressionOffsets"], jsonDecoder.decodeInt) as List<int>;
15626 } 15626 }
15627 List<int> coveringExpressionLengths; 15627 List<int> coveringExpressionLengths;
15628 if (json.containsKey("coveringExpressionLengths")) { 15628 if (json.containsKey("coveringExpressionLengths")) {
15629 coveringExpressionLengths = jsonDecoder.decodeList(jsonPath + ".covering ExpressionLengths", json["coveringExpressionLengths"], jsonDecoder.decodeInt); 15629 coveringExpressionLengths = jsonDecoder.decodeList(jsonPath + ".covering ExpressionLengths", json["coveringExpressionLengths"], jsonDecoder.decodeInt) as List<int>;
15630 } 15630 }
15631 List<String> names; 15631 List<String> names;
15632 if (json.containsKey("names")) { 15632 if (json.containsKey("names")) {
15633 names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonD ecoder.decodeString); 15633 names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonD ecoder.decodeString) as List<String>;
15634 } else { 15634 } else {
15635 throw jsonDecoder.missingKey(jsonPath, "names"); 15635 throw jsonDecoder.missingKey(jsonPath, "names");
15636 } 15636 }
15637 List<int> offsets; 15637 List<int> offsets;
15638 if (json.containsKey("offsets")) { 15638 if (json.containsKey("offsets")) {
15639 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt); 15639 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt) as List<int>;
15640 } else { 15640 } else {
15641 throw jsonDecoder.missingKey(jsonPath, "offsets"); 15641 throw jsonDecoder.missingKey(jsonPath, "offsets");
15642 } 15642 }
15643 List<int> lengths; 15643 List<int> lengths;
15644 if (json.containsKey("lengths")) { 15644 if (json.containsKey("lengths")) {
15645 lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt); 15645 lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt) as List<int>;
15646 } else { 15646 } else {
15647 throw jsonDecoder.missingKey(jsonPath, "lengths"); 15647 throw jsonDecoder.missingKey(jsonPath, "lengths");
15648 } 15648 }
15649 return new ExtractLocalVariableFeedback(names, offsets, lengths, coveringE xpressionOffsets: coveringExpressionOffsets, coveringExpressionLengths: covering ExpressionLengths); 15649 return new ExtractLocalVariableFeedback(names, offsets, lengths, coveringE xpressionOffsets: coveringExpressionOffsets, coveringExpressionLengths: covering ExpressionLengths);
15650 } else { 15650 } else {
15651 throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json ); 15651 throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback", json );
15652 } 15652 }
15653 } 15653 }
15654 15654
15655 Map<String, dynamic> toJson() { 15655 Map<String, dynamic> toJson() {
(...skipping 325 matching lines...) Expand 10 before | Expand all | Expand 10 after
15981 throw jsonDecoder.missingKey(jsonPath, "length"); 15981 throw jsonDecoder.missingKey(jsonPath, "length");
15982 } 15982 }
15983 String returnType; 15983 String returnType;
15984 if (json.containsKey("returnType")) { 15984 if (json.containsKey("returnType")) {
15985 returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["re turnType"]); 15985 returnType = jsonDecoder.decodeString(jsonPath + ".returnType", json["re turnType"]);
15986 } else { 15986 } else {
15987 throw jsonDecoder.missingKey(jsonPath, "returnType"); 15987 throw jsonDecoder.missingKey(jsonPath, "returnType");
15988 } 15988 }
15989 List<String> names; 15989 List<String> names;
15990 if (json.containsKey("names")) { 15990 if (json.containsKey("names")) {
15991 names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonD ecoder.decodeString); 15991 names = jsonDecoder.decodeList(jsonPath + ".names", json["names"], jsonD ecoder.decodeString) as List<String>;
15992 } else { 15992 } else {
15993 throw jsonDecoder.missingKey(jsonPath, "names"); 15993 throw jsonDecoder.missingKey(jsonPath, "names");
15994 } 15994 }
15995 bool canCreateGetter; 15995 bool canCreateGetter;
15996 if (json.containsKey("canCreateGetter")) { 15996 if (json.containsKey("canCreateGetter")) {
15997 canCreateGetter = jsonDecoder.decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]); 15997 canCreateGetter = jsonDecoder.decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
15998 } else { 15998 } else {
15999 throw jsonDecoder.missingKey(jsonPath, "canCreateGetter"); 15999 throw jsonDecoder.missingKey(jsonPath, "canCreateGetter");
16000 } 16000 }
16001 List<RefactoringMethodParameter> parameters; 16001 List<RefactoringMethodParameter> parameters;
16002 if (json.containsKey("parameters")) { 16002 if (json.containsKey("parameters")) {
16003 parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["para meters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJ son(jsonDecoder, jsonPath, json)); 16003 parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["para meters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJ son(jsonDecoder, jsonPath, json)) as List<RefactoringMethodParameter>;
16004 } else { 16004 } else {
16005 throw jsonDecoder.missingKey(jsonPath, "parameters"); 16005 throw jsonDecoder.missingKey(jsonPath, "parameters");
16006 } 16006 }
16007 List<int> offsets; 16007 List<int> offsets;
16008 if (json.containsKey("offsets")) { 16008 if (json.containsKey("offsets")) {
16009 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt); 16009 offsets = jsonDecoder.decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder.decodeInt) as List<int>;
16010 } else { 16010 } else {
16011 throw jsonDecoder.missingKey(jsonPath, "offsets"); 16011 throw jsonDecoder.missingKey(jsonPath, "offsets");
16012 } 16012 }
16013 List<int> lengths; 16013 List<int> lengths;
16014 if (json.containsKey("lengths")) { 16014 if (json.containsKey("lengths")) {
16015 lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt); 16015 lengths = jsonDecoder.decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder.decodeInt) as List<int>;
16016 } else { 16016 } else {
16017 throw jsonDecoder.missingKey(jsonPath, "lengths"); 16017 throw jsonDecoder.missingKey(jsonPath, "lengths");
16018 } 16018 }
16019 return new ExtractMethodFeedback(offset, length, returnType, names, canCre ateGetter, parameters, offsets, lengths); 16019 return new ExtractMethodFeedback(offset, length, returnType, names, canCre ateGetter, parameters, offsets, lengths);
16020 } else { 16020 } else {
16021 throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json); 16021 throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback", json);
16022 } 16022 }
16023 } 16023 }
16024 16024
16025 Map<String, dynamic> toJson() { 16025 Map<String, dynamic> toJson() {
(...skipping 181 matching lines...) Expand 10 before | Expand all | Expand 10 after
16207 throw jsonDecoder.missingKey(jsonPath, "createGetter"); 16207 throw jsonDecoder.missingKey(jsonPath, "createGetter");
16208 } 16208 }
16209 String name; 16209 String name;
16210 if (json.containsKey("name")) { 16210 if (json.containsKey("name")) {
16211 name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]); 16211 name = jsonDecoder.decodeString(jsonPath + ".name", json["name"]);
16212 } else { 16212 } else {
16213 throw jsonDecoder.missingKey(jsonPath, "name"); 16213 throw jsonDecoder.missingKey(jsonPath, "name");
16214 } 16214 }
16215 List<RefactoringMethodParameter> parameters; 16215 List<RefactoringMethodParameter> parameters;
16216 if (json.containsKey("parameters")) { 16216 if (json.containsKey("parameters")) {
16217 parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["para meters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJ son(jsonDecoder, jsonPath, json)); 16217 parameters = jsonDecoder.decodeList(jsonPath + ".parameters", json["para meters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJ son(jsonDecoder, jsonPath, json)) as List<RefactoringMethodParameter>;
16218 } else { 16218 } else {
16219 throw jsonDecoder.missingKey(jsonPath, "parameters"); 16219 throw jsonDecoder.missingKey(jsonPath, "parameters");
16220 } 16220 }
16221 bool extractAll; 16221 bool extractAll;
16222 if (json.containsKey("extractAll")) { 16222 if (json.containsKey("extractAll")) {
16223 extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extr actAll"]); 16223 extractAll = jsonDecoder.decodeBool(jsonPath + ".extractAll", json["extr actAll"]);
16224 } else { 16224 } else {
16225 throw jsonDecoder.missingKey(jsonPath, "extractAll"); 16225 throw jsonDecoder.missingKey(jsonPath, "extractAll");
16226 } 16226 }
16227 return new ExtractMethodOptions(returnType, createGetter, name, parameters , extractAll); 16227 return new ExtractMethodOptions(returnType, createGetter, name, parameters , extractAll);
(...skipping 706 matching lines...) Expand 10 before | Expand all | Expand 10 after
16934 return false; 16934 return false;
16935 } 16935 }
16936 16936
16937 @override 16937 @override
16938 int get hashCode { 16938 int get hashCode {
16939 int hash = 0; 16939 int hash = 0;
16940 hash = JenkinsSmiHash.combine(hash, newName.hashCode); 16940 hash = JenkinsSmiHash.combine(hash, newName.hashCode);
16941 return JenkinsSmiHash.finish(hash); 16941 return JenkinsSmiHash.finish(hash);
16942 } 16942 }
16943 } 16943 }
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698