| Index: pkg/analysis_server/lib/src/generated_protocol.dart
|
| diff --git a/pkg/analysis_server/lib/src/generated_protocol.dart b/pkg/analysis_server/lib/src/generated_protocol.dart
|
| new file mode 100644
|
| index 0000000000000000000000000000000000000000..655368de9608369e74dd4d60ef5563539f57bc3b
|
| --- /dev/null
|
| +++ b/pkg/analysis_server/lib/src/generated_protocol.dart
|
| @@ -0,0 +1,8552 @@
|
| +// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
|
| +// for details. All rights reserved. Use of this source code is governed by a
|
| +// BSD-style license that can be found in the LICENSE file.
|
| +//
|
| +// This file has been automatically generated. Please do not edit it manually.
|
| +// To regenerate the file, use the script
|
| +// "pkg/analysis_server/spec/generate_files".
|
| +
|
| +part of protocol2;
|
| +
|
| +/**
|
| + * server.getVersion result
|
| + *
|
| + * {
|
| + * "version": String
|
| + * }
|
| + */
|
| +class ServerGetVersionResult {
|
| + /**
|
| + * The version number of the analysis server.
|
| + */
|
| + final String version;
|
| +
|
| + ServerGetVersionResult(this.version);
|
| +
|
| + factory ServerGetVersionResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String version;
|
| + if (json.containsKey("version")) {
|
| + version = jsonDecoder._decodeString(jsonPath + ".version", json["version"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "version");
|
| + }
|
| + return new ServerGetVersionResult(version);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "server.getVersion result");
|
| + }
|
| + }
|
| +
|
| + factory ServerGetVersionResult.fromResponse(Response response) {
|
| + return new ServerGetVersionResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["version"] = version;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ServerGetVersionResult) {
|
| + return version == other.version;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, version.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * server.setSubscriptions params
|
| + *
|
| + * {
|
| + * "subscriptions": List<ServerService>
|
| + * }
|
| + */
|
| +class ServerSetSubscriptionsParams {
|
| + /**
|
| + * A list of the services being subscribed to.
|
| + */
|
| + final List<ServerService> subscriptions;
|
| +
|
| + ServerSetSubscriptionsParams(this.subscriptions);
|
| +
|
| + factory ServerSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<ServerService> subscriptions;
|
| + if (json.containsKey("subscriptions")) {
|
| + subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new ServerService.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "subscriptions");
|
| + }
|
| + return new ServerSetSubscriptionsParams(subscriptions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "server.setSubscriptions params");
|
| + }
|
| + }
|
| +
|
| + factory ServerSetSubscriptionsParams.fromRequest(Request request) {
|
| + return new ServerSetSubscriptionsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["subscriptions"] = subscriptions.map((ServerService value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ServerSetSubscriptionsParams) {
|
| + return _listEqual(subscriptions, other.subscriptions, (ServerService a, ServerService b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * server.error params
|
| + *
|
| + * {
|
| + * "fatal": bool
|
| + * "message": String
|
| + * "stackTrace": String
|
| + * }
|
| + */
|
| +class ServerErrorParams {
|
| + /**
|
| + * True if the error is a fatal error, meaning that the server will shutdown
|
| + * automatically after sending this notification.
|
| + */
|
| + final bool fatal;
|
| +
|
| + /**
|
| + * The error message indicating what kind of error was encountered.
|
| + */
|
| + final String message;
|
| +
|
| + /**
|
| + * The stack trace associated with the generation of the error, used for
|
| + * debugging the server.
|
| + */
|
| + final String stackTrace;
|
| +
|
| + ServerErrorParams(this.fatal, this.message, this.stackTrace);
|
| +
|
| + factory ServerErrorParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + bool fatal;
|
| + if (json.containsKey("fatal")) {
|
| + fatal = jsonDecoder._decodeBool(jsonPath + ".fatal", json["fatal"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "fatal");
|
| + }
|
| + String message;
|
| + if (json.containsKey("message")) {
|
| + message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "message");
|
| + }
|
| + String stackTrace;
|
| + if (json.containsKey("stackTrace")) {
|
| + stackTrace = jsonDecoder._decodeString(jsonPath + ".stackTrace", json["stackTrace"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "stackTrace");
|
| + }
|
| + return new ServerErrorParams(fatal, message, stackTrace);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "server.error params");
|
| + }
|
| + }
|
| +
|
| + factory ServerErrorParams.fromNotification(Notification notification) {
|
| + return new ServerErrorParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["fatal"] = fatal;
|
| + result["message"] = message;
|
| + result["stackTrace"] = stackTrace;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ServerErrorParams) {
|
| + return fatal == other.fatal &&
|
| + message == other.message &&
|
| + stackTrace == other.stackTrace;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, fatal.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, message.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, stackTrace.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * server.status params
|
| + *
|
| + * {
|
| + * "analysis": optional AnalysisStatus
|
| + * }
|
| + */
|
| +class ServerStatusParams {
|
| + /**
|
| + * The current status of analysis, including whether analysis is being
|
| + * performed and if so what is being analyzed.
|
| + */
|
| + final AnalysisStatus analysis;
|
| +
|
| + ServerStatusParams({this.analysis});
|
| +
|
| + factory ServerStatusParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + AnalysisStatus analysis;
|
| + if (json.containsKey("analysis")) {
|
| + analysis = new AnalysisStatus.fromJson(jsonDecoder, jsonPath + ".analysis", json["analysis"]);
|
| + }
|
| + return new ServerStatusParams(analysis: analysis);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "server.status params");
|
| + }
|
| + }
|
| +
|
| + factory ServerStatusParams.fromNotification(Notification notification) {
|
| + return new ServerStatusParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + if (analysis != null) {
|
| + result["analysis"] = analysis.toJson();
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ServerStatusParams) {
|
| + return analysis == other.analysis;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, analysis.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.getErrors params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * }
|
| + */
|
| +class AnalysisGetErrorsParams {
|
| + /**
|
| + * The file for which errors are being requested.
|
| + */
|
| + final String file;
|
| +
|
| + AnalysisGetErrorsParams(this.file);
|
| +
|
| + factory AnalysisGetErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + return new AnalysisGetErrorsParams(file);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisGetErrorsParams.fromRequest(Request request) {
|
| + return new AnalysisGetErrorsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisGetErrorsParams) {
|
| + return file == other.file;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.getErrors result
|
| + *
|
| + * {
|
| + * "errors": List<AnalysisError>
|
| + * }
|
| + */
|
| +class AnalysisGetErrorsResult {
|
| + /**
|
| + * The errors associated with the file.
|
| + */
|
| + final List<AnalysisError> errors;
|
| +
|
| + AnalysisGetErrorsResult(this.errors);
|
| +
|
| + factory AnalysisGetErrorsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<AnalysisError> errors;
|
| + if (json.containsKey("errors")) {
|
| + errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "errors");
|
| + }
|
| + return new AnalysisGetErrorsResult(errors);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.getErrors result");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisGetErrorsResult.fromResponse(Response response) {
|
| + return new AnalysisGetErrorsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["errors"] = errors.map((AnalysisError value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisGetErrorsResult) {
|
| + return _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, errors.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.getHover params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * }
|
| + */
|
| +class AnalysisGetHoverParams {
|
| + /**
|
| + * The file in which hover information is being requested.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset for which hover information is being requested.
|
| + */
|
| + final int offset;
|
| +
|
| + AnalysisGetHoverParams(this.file, this.offset);
|
| +
|
| + factory AnalysisGetHoverParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new AnalysisGetHoverParams(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.getHover params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisGetHoverParams.fromRequest(Request request) {
|
| + return new AnalysisGetHoverParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisGetHoverParams) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.getHover result
|
| + *
|
| + * {
|
| + * "hovers": List<HoverInformation>
|
| + * }
|
| + */
|
| +class AnalysisGetHoverResult {
|
| + /**
|
| + * The hover information associated with the location. The list will be empty
|
| + * if no information could be determined for the location. The list can
|
| + * contain multiple items if the file is being analyzed in multiple contexts
|
| + * in conflicting ways (such as a part that is included in multiple
|
| + * libraries).
|
| + */
|
| + final List<HoverInformation> hovers;
|
| +
|
| + AnalysisGetHoverResult(this.hovers);
|
| +
|
| + factory AnalysisGetHoverResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<HoverInformation> hovers;
|
| + if (json.containsKey("hovers")) {
|
| + hovers = jsonDecoder._decodeList(jsonPath + ".hovers", json["hovers"], (String jsonPath, Object json) => new HoverInformation.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "hovers");
|
| + }
|
| + return new AnalysisGetHoverResult(hovers);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.getHover result");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisGetHoverResult.fromResponse(Response response) {
|
| + return new AnalysisGetHoverResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["hovers"] = hovers.map((HoverInformation value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisGetHoverResult) {
|
| + return _listEqual(hovers, other.hovers, (HoverInformation a, HoverInformation b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, hovers.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.setAnalysisRoots params
|
| + *
|
| + * {
|
| + * "included": List<FilePath>
|
| + * "excluded": List<FilePath>
|
| + * }
|
| + */
|
| +class AnalysisSetAnalysisRootsParams {
|
| + /**
|
| + * A list of the files and directories that should be analyzed.
|
| + */
|
| + final List<String> included;
|
| +
|
| + /**
|
| + * A list of the files and directories within the included directories that
|
| + * should not be analyzed.
|
| + */
|
| + final List<String> excluded;
|
| +
|
| + AnalysisSetAnalysisRootsParams(this.included, this.excluded);
|
| +
|
| + factory AnalysisSetAnalysisRootsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<String> included;
|
| + if (json.containsKey("included")) {
|
| + included = jsonDecoder._decodeList(jsonPath + ".included", json["included"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "included");
|
| + }
|
| + List<String> excluded;
|
| + if (json.containsKey("excluded")) {
|
| + excluded = jsonDecoder._decodeList(jsonPath + ".excluded", json["excluded"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "excluded");
|
| + }
|
| + return new AnalysisSetAnalysisRootsParams(included, excluded);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.setAnalysisRoots params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisSetAnalysisRootsParams.fromRequest(Request request) {
|
| + return new AnalysisSetAnalysisRootsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["included"] = included;
|
| + result["excluded"] = excluded;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisSetAnalysisRootsParams) {
|
| + return _listEqual(included, other.included, (String a, String b) => a == b) &&
|
| + _listEqual(excluded, other.excluded, (String a, String b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, included.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, excluded.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.setPriorityFiles params
|
| + *
|
| + * {
|
| + * "files": List<FilePath>
|
| + * }
|
| + */
|
| +class AnalysisSetPriorityFilesParams {
|
| + /**
|
| + * The files that are to be a priority for analysis.
|
| + */
|
| + final List<String> files;
|
| +
|
| + AnalysisSetPriorityFilesParams(this.files);
|
| +
|
| + factory AnalysisSetPriorityFilesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<String> files;
|
| + if (json.containsKey("files")) {
|
| + files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "files");
|
| + }
|
| + return new AnalysisSetPriorityFilesParams(files);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.setPriorityFiles params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisSetPriorityFilesParams.fromRequest(Request request) {
|
| + return new AnalysisSetPriorityFilesParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["files"] = files;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisSetPriorityFilesParams) {
|
| + return _listEqual(files, other.files, (String a, String b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, files.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.setSubscriptions params
|
| + *
|
| + * {
|
| + * "subscriptions": Map<AnalysisService, List<FilePath>>
|
| + * }
|
| + */
|
| +class AnalysisSetSubscriptionsParams {
|
| + /**
|
| + * A table mapping services to a list of the files being subscribed to the
|
| + * service.
|
| + */
|
| + final Map<AnalysisService, List<String>> subscriptions;
|
| +
|
| + AnalysisSetSubscriptionsParams(this.subscriptions);
|
| +
|
| + factory AnalysisSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Map<AnalysisService, List<String>> subscriptions;
|
| + if (json.containsKey("subscriptions")) {
|
| + subscriptions = jsonDecoder._decodeMap(jsonPath + ".subscriptions", json["subscriptions"], keyDecoder: (String jsonPath, Object json) => new AnalysisService.fromJson(jsonDecoder, jsonPath, json), valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "subscriptions");
|
| + }
|
| + return new AnalysisSetSubscriptionsParams(subscriptions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.setSubscriptions params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisSetSubscriptionsParams.fromRequest(Request request) {
|
| + return new AnalysisSetSubscriptionsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["subscriptions"] = _mapMap(subscriptions, keyCallback: (AnalysisService value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisSetSubscriptionsParams) {
|
| + return _mapEqual(subscriptions, other.subscriptions, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b));
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.updateContent params
|
| + *
|
| + * {
|
| + * "files": Map<FilePath, AddContentOverlay | ChangeContentOverlay | RemoveContentOverlay>
|
| + * }
|
| + */
|
| +class AnalysisUpdateContentParams {
|
| + /**
|
| + * A table mapping the files whose content has changed to a description of
|
| + * the content change.
|
| + */
|
| + final Map<String, dynamic> files;
|
| +
|
| + AnalysisUpdateContentParams(this.files);
|
| +
|
| + factory AnalysisUpdateContentParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Map<String, dynamic> files;
|
| + if (json.containsKey("files")) {
|
| + files = jsonDecoder._decodeMap(jsonPath + ".files", json["files"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeUnion(jsonPath, json, "type", {"add": (String jsonPath, Object json) => new AddContentOverlay.fromJson(jsonDecoder, jsonPath, json), "change": (String jsonPath, Object json) => new ChangeContentOverlay.fromJson(jsonDecoder, jsonPath, json), "remove": (String jsonPath, Object json) => new RemoveContentOverlay.fromJson(jsonDecoder, jsonPath, json)}));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "files");
|
| + }
|
| + return new AnalysisUpdateContentParams(files);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.updateContent params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisUpdateContentParams.fromRequest(Request request) {
|
| + return new AnalysisUpdateContentParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["files"] = _mapMap(files, valueCallback: (dynamic value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisUpdateContentParams) {
|
| + return _mapEqual(files, other.files, (dynamic a, dynamic b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, files.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.updateOptions params
|
| + *
|
| + * {
|
| + * "options": AnalysisOptions
|
| + * }
|
| + */
|
| +class AnalysisUpdateOptionsParams {
|
| + /**
|
| + * The options that are to be used to control analysis.
|
| + */
|
| + final AnalysisOptions options;
|
| +
|
| + AnalysisUpdateOptionsParams(this.options);
|
| +
|
| + factory AnalysisUpdateOptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + AnalysisOptions options;
|
| + if (json.containsKey("options")) {
|
| + options = new AnalysisOptions.fromJson(jsonDecoder, jsonPath + ".options", json["options"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "options");
|
| + }
|
| + return new AnalysisUpdateOptionsParams(options);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.updateOptions params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisUpdateOptionsParams.fromRequest(Request request) {
|
| + return new AnalysisUpdateOptionsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["options"] = options.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisUpdateOptionsParams) {
|
| + return options == other.options;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, options.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.errors params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "errors": List<AnalysisError>
|
| + * }
|
| + */
|
| +class AnalysisErrorsParams {
|
| + /**
|
| + * The file containing the errors.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The errors contained in the file.
|
| + */
|
| + final List<AnalysisError> errors;
|
| +
|
| + AnalysisErrorsParams(this.file, this.errors);
|
| +
|
| + factory AnalysisErrorsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<AnalysisError> errors;
|
| + if (json.containsKey("errors")) {
|
| + errors = jsonDecoder._decodeList(jsonPath + ".errors", json["errors"], (String jsonPath, Object json) => new AnalysisError.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "errors");
|
| + }
|
| + return new AnalysisErrorsParams(file, errors);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.errors params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisErrorsParams.fromNotification(Notification notification) {
|
| + return new AnalysisErrorsParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["errors"] = errors.map((AnalysisError value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisErrorsParams) {
|
| + return file == other.file &&
|
| + _listEqual(errors, other.errors, (AnalysisError a, AnalysisError b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, errors.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.flushResults params
|
| + *
|
| + * {
|
| + * "files": List<FilePath>
|
| + * }
|
| + */
|
| +class AnalysisFlushResultsParams {
|
| + /**
|
| + * The files that are no longer being analyzed.
|
| + */
|
| + final List<String> files;
|
| +
|
| + AnalysisFlushResultsParams(this.files);
|
| +
|
| + factory AnalysisFlushResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<String> files;
|
| + if (json.containsKey("files")) {
|
| + files = jsonDecoder._decodeList(jsonPath + ".files", json["files"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "files");
|
| + }
|
| + return new AnalysisFlushResultsParams(files);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.flushResults params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisFlushResultsParams.fromNotification(Notification notification) {
|
| + return new AnalysisFlushResultsParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["files"] = files;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisFlushResultsParams) {
|
| + return _listEqual(files, other.files, (String a, String b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, files.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.folding params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "regions": List<FoldingRegion>
|
| + * }
|
| + */
|
| +class AnalysisFoldingParams {
|
| + /**
|
| + * The file containing the folding regions.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The folding regions contained in the file.
|
| + */
|
| + final List<FoldingRegion> regions;
|
| +
|
| + AnalysisFoldingParams(this.file, this.regions);
|
| +
|
| + factory AnalysisFoldingParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<FoldingRegion> regions;
|
| + if (json.containsKey("regions")) {
|
| + regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new FoldingRegion.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "regions");
|
| + }
|
| + return new AnalysisFoldingParams(file, regions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.folding params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisFoldingParams.fromNotification(Notification notification) {
|
| + return new AnalysisFoldingParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["regions"] = regions.map((FoldingRegion value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisFoldingParams) {
|
| + return file == other.file &&
|
| + _listEqual(regions, other.regions, (FoldingRegion a, FoldingRegion b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.highlights params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "regions": List<HighlightRegion>
|
| + * }
|
| + */
|
| +class AnalysisHighlightsParams {
|
| + /**
|
| + * The file containing the highlight regions.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The highlight regions contained in the file. Each highlight region
|
| + * represents a particular syntactic or semantic meaning associated with some
|
| + * range. Note that the highlight regions that are returned can overlap other
|
| + * highlight regions if there is more than one meaning associated with a
|
| + * particular region.
|
| + */
|
| + final List<HighlightRegion> regions;
|
| +
|
| + AnalysisHighlightsParams(this.file, this.regions);
|
| +
|
| + factory AnalysisHighlightsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<HighlightRegion> regions;
|
| + if (json.containsKey("regions")) {
|
| + regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new HighlightRegion.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "regions");
|
| + }
|
| + return new AnalysisHighlightsParams(file, regions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.highlights params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisHighlightsParams.fromNotification(Notification notification) {
|
| + return new AnalysisHighlightsParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["regions"] = regions.map((HighlightRegion value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisHighlightsParams) {
|
| + return file == other.file &&
|
| + _listEqual(regions, other.regions, (HighlightRegion a, HighlightRegion b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.navigation params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "regions": List<NavigationRegion>
|
| + * }
|
| + */
|
| +class AnalysisNavigationParams {
|
| + /**
|
| + * The file containing the navigation regions.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The navigation regions contained in the file. Each navigation region
|
| + * represents a list of targets associated with some range. The lists will
|
| + * usually contain a single target, but can contain more in the case of a
|
| + * part that is included in multiple libraries or in Dart code that is
|
| + * compiled against multiple versions of a package. Note that the navigation
|
| + * regions that are returned do not overlap other navigation regions.
|
| + */
|
| + final List<NavigationRegion> regions;
|
| +
|
| + AnalysisNavigationParams(this.file, this.regions);
|
| +
|
| + factory AnalysisNavigationParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<NavigationRegion> regions;
|
| + if (json.containsKey("regions")) {
|
| + regions = jsonDecoder._decodeList(jsonPath + ".regions", json["regions"], (String jsonPath, Object json) => new NavigationRegion.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "regions");
|
| + }
|
| + return new AnalysisNavigationParams(file, regions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.navigation params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisNavigationParams.fromNotification(Notification notification) {
|
| + return new AnalysisNavigationParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["regions"] = regions.map((NavigationRegion value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisNavigationParams) {
|
| + return file == other.file &&
|
| + _listEqual(regions, other.regions, (NavigationRegion a, NavigationRegion b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, regions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.occurrences params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "occurrences": List<Occurrences>
|
| + * }
|
| + */
|
| +class AnalysisOccurrencesParams {
|
| + /**
|
| + * The file in which the references occur.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The occurrences of references to elements within the file.
|
| + */
|
| + final List<Occurrences> occurrences;
|
| +
|
| + AnalysisOccurrencesParams(this.file, this.occurrences);
|
| +
|
| + factory AnalysisOccurrencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<Occurrences> occurrences;
|
| + if (json.containsKey("occurrences")) {
|
| + occurrences = jsonDecoder._decodeList(jsonPath + ".occurrences", json["occurrences"], (String jsonPath, Object json) => new Occurrences.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "occurrences");
|
| + }
|
| + return new AnalysisOccurrencesParams(file, occurrences);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.occurrences params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisOccurrencesParams.fromNotification(Notification notification) {
|
| + return new AnalysisOccurrencesParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["occurrences"] = occurrences.map((Occurrences value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisOccurrencesParams) {
|
| + return file == other.file &&
|
| + _listEqual(occurrences, other.occurrences, (Occurrences a, Occurrences b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.outline params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "outline": Outline
|
| + * }
|
| + */
|
| +class AnalysisOutlineParams {
|
| + /**
|
| + * The file with which the outline is associated.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The outline associated with the file.
|
| + */
|
| + final Outline outline;
|
| +
|
| + AnalysisOutlineParams(this.file, this.outline);
|
| +
|
| + factory AnalysisOutlineParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + Outline outline;
|
| + if (json.containsKey("outline")) {
|
| + outline = new Outline.fromJson(jsonDecoder, jsonPath + ".outline", json["outline"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "outline");
|
| + }
|
| + return new AnalysisOutlineParams(file, outline);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.outline params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisOutlineParams.fromNotification(Notification notification) {
|
| + return new AnalysisOutlineParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["outline"] = outline.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisOutlineParams) {
|
| + return file == other.file &&
|
| + outline == other.outline;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, outline.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * analysis.overrides params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "overrides": List<Override>
|
| + * }
|
| + */
|
| +class AnalysisOverridesParams {
|
| + /**
|
| + * The file with which the overrides are associated.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The overrides associated with the file.
|
| + */
|
| + final List<Override> overrides;
|
| +
|
| + AnalysisOverridesParams(this.file, this.overrides);
|
| +
|
| + factory AnalysisOverridesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<Override> overrides;
|
| + if (json.containsKey("overrides")) {
|
| + overrides = jsonDecoder._decodeList(jsonPath + ".overrides", json["overrides"], (String jsonPath, Object json) => new Override.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "overrides");
|
| + }
|
| + return new AnalysisOverridesParams(file, overrides);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "analysis.overrides params");
|
| + }
|
| + }
|
| +
|
| + factory AnalysisOverridesParams.fromNotification(Notification notification) {
|
| + return new AnalysisOverridesParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["overrides"] = overrides.map((Override value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisOverridesParams) {
|
| + return file == other.file &&
|
| + _listEqual(overrides, other.overrides, (Override a, Override b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, overrides.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * completion.getSuggestions params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * }
|
| + */
|
| +class CompletionGetSuggestionsParams {
|
| + /**
|
| + * The file containing the point at which suggestions are to be made.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset within the file at which suggestions are to be made.
|
| + */
|
| + final int offset;
|
| +
|
| + CompletionGetSuggestionsParams(this.file, this.offset);
|
| +
|
| + factory CompletionGetSuggestionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new CompletionGetSuggestionsParams(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions params");
|
| + }
|
| + }
|
| +
|
| + factory CompletionGetSuggestionsParams.fromRequest(Request request) {
|
| + return new CompletionGetSuggestionsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is CompletionGetSuggestionsParams) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * completion.getSuggestions result
|
| + *
|
| + * {
|
| + * "id": CompletionId
|
| + * }
|
| + */
|
| +class CompletionGetSuggestionsResult {
|
| + /**
|
| + * The identifier used to associate results with this completion request.
|
| + */
|
| + final String id;
|
| +
|
| + CompletionGetSuggestionsResult(this.id);
|
| +
|
| + factory CompletionGetSuggestionsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new CompletionGetSuggestionsResult(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "completion.getSuggestions result");
|
| + }
|
| + }
|
| +
|
| + factory CompletionGetSuggestionsResult.fromResponse(Response response) {
|
| + return new CompletionGetSuggestionsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is CompletionGetSuggestionsResult) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * completion.results params
|
| + *
|
| + * {
|
| + * "id": CompletionId
|
| + * "replacementOffset": int
|
| + * "replacementLength": int
|
| + * "results": List<CompletionSuggestion>
|
| + * "last": bool
|
| + * }
|
| + */
|
| +class CompletionResultsParams {
|
| + /**
|
| + * The id associated with the completion.
|
| + */
|
| + final String id;
|
| +
|
| + /**
|
| + * The offset of the start of the text to be replaced. This will be different
|
| + * than the offset used to request the completion suggestions if there was a
|
| + * portion of an identifier before the original offset. In particular, the
|
| + * replacementOffset will be the offset of the beginning of said identifier.
|
| + */
|
| + final int replacementOffset;
|
| +
|
| + /**
|
| + * The length of the text to be replaced if the remainder of the identifier
|
| + * containing the cursor is to be replaced when the suggestion is applied
|
| + * (that is, the number of characters in the existing identifier).
|
| + */
|
| + final int replacementLength;
|
| +
|
| + /**
|
| + * The completion suggestions being reported. The notification contains all
|
| + * possible completions at the requested cursor position, even those that do
|
| + * not match the characters the user has already typed. This allows the
|
| + * client to respond to further keystrokes from the user without having to
|
| + * make additional requests.
|
| + */
|
| + final List<CompletionSuggestion> results;
|
| +
|
| + /**
|
| + * True if this is that last set of results that will be returned for the
|
| + * indicated completion.
|
| + */
|
| + final bool last;
|
| +
|
| + CompletionResultsParams(this.id, this.replacementOffset, this.replacementLength, this.results, this.last);
|
| +
|
| + factory CompletionResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + int replacementOffset;
|
| + if (json.containsKey("replacementOffset")) {
|
| + replacementOffset = jsonDecoder._decodeInt(jsonPath + ".replacementOffset", json["replacementOffset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "replacementOffset");
|
| + }
|
| + int replacementLength;
|
| + if (json.containsKey("replacementLength")) {
|
| + replacementLength = jsonDecoder._decodeInt(jsonPath + ".replacementLength", json["replacementLength"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "replacementLength");
|
| + }
|
| + List<CompletionSuggestion> results;
|
| + if (json.containsKey("results")) {
|
| + results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new CompletionSuggestion.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "results");
|
| + }
|
| + bool last;
|
| + if (json.containsKey("last")) {
|
| + last = jsonDecoder._decodeBool(jsonPath + ".last", json["last"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "last");
|
| + }
|
| + return new CompletionResultsParams(id, replacementOffset, replacementLength, results, last);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "completion.results params");
|
| + }
|
| + }
|
| +
|
| + factory CompletionResultsParams.fromNotification(Notification notification) {
|
| + return new CompletionResultsParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + result["replacementOffset"] = replacementOffset;
|
| + result["replacementLength"] = replacementLength;
|
| + result["results"] = results.map((CompletionSuggestion value) => value.toJson());
|
| + result["last"] = last;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is CompletionResultsParams) {
|
| + return id == other.id &&
|
| + replacementOffset == other.replacementOffset &&
|
| + replacementLength == other.replacementLength &&
|
| + _listEqual(results, other.results, (CompletionSuggestion a, CompletionSuggestion b) => a == b) &&
|
| + last == other.last;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, replacementOffset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, replacementLength.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, results.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, last.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findElementReferences params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * "includePotential": bool
|
| + * }
|
| + */
|
| +class SearchFindElementReferencesParams {
|
| + /**
|
| + * The file containing the declaration of or reference to the element used to
|
| + * define the search.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset within the file of the declaration of or reference to the
|
| + * element.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * True if potential matches are to be included in the results.
|
| + */
|
| + final bool includePotential;
|
| +
|
| + SearchFindElementReferencesParams(this.file, this.offset, this.includePotential);
|
| +
|
| + factory SearchFindElementReferencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + bool includePotential;
|
| + if (json.containsKey("includePotential")) {
|
| + includePotential = jsonDecoder._decodeBool(jsonPath + ".includePotential", json["includePotential"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "includePotential");
|
| + }
|
| + return new SearchFindElementReferencesParams(file, offset, includePotential);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences params");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindElementReferencesParams.fromRequest(Request request) {
|
| + return new SearchFindElementReferencesParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + result["includePotential"] = includePotential;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindElementReferencesParams) {
|
| + return file == other.file &&
|
| + offset == other.offset &&
|
| + includePotential == other.includePotential;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, includePotential.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findElementReferences result
|
| + *
|
| + * {
|
| + * "id": SearchId
|
| + * "element": Element
|
| + * }
|
| + */
|
| +class SearchFindElementReferencesResult {
|
| + /**
|
| + * The identifier used to associate results with this search request.
|
| + */
|
| + final String id;
|
| +
|
| + /**
|
| + * The element referenced or defined at the given offset and whose references
|
| + * will be returned in the search results.
|
| + */
|
| + final Element element;
|
| +
|
| + SearchFindElementReferencesResult(this.id, this.element);
|
| +
|
| + factory SearchFindElementReferencesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + Element element;
|
| + if (json.containsKey("element")) {
|
| + element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "element");
|
| + }
|
| + return new SearchFindElementReferencesResult(id, element);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findElementReferences result");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindElementReferencesResult.fromResponse(Response response) {
|
| + return new SearchFindElementReferencesResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + result["element"] = element.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindElementReferencesResult) {
|
| + return id == other.id &&
|
| + element == other.element;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, element.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findMemberDeclarations params
|
| + *
|
| + * {
|
| + * "name": String
|
| + * }
|
| + */
|
| +class SearchFindMemberDeclarationsParams {
|
| + /**
|
| + * The name of the declarations to be found.
|
| + */
|
| + final String name;
|
| +
|
| + SearchFindMemberDeclarationsParams(this.name);
|
| +
|
| + factory SearchFindMemberDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + return new SearchFindMemberDeclarationsParams(name);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations params");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindMemberDeclarationsParams.fromRequest(Request request) {
|
| + return new SearchFindMemberDeclarationsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["name"] = name;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindMemberDeclarationsParams) {
|
| + return name == other.name;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findMemberDeclarations result
|
| + *
|
| + * {
|
| + * "id": SearchId
|
| + * }
|
| + */
|
| +class SearchFindMemberDeclarationsResult {
|
| + /**
|
| + * The identifier used to associate results with this search request.
|
| + */
|
| + final String id;
|
| +
|
| + SearchFindMemberDeclarationsResult(this.id);
|
| +
|
| + factory SearchFindMemberDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new SearchFindMemberDeclarationsResult(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findMemberDeclarations result");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindMemberDeclarationsResult.fromResponse(Response response) {
|
| + return new SearchFindMemberDeclarationsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindMemberDeclarationsResult) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findMemberReferences params
|
| + *
|
| + * {
|
| + * "name": String
|
| + * }
|
| + */
|
| +class SearchFindMemberReferencesParams {
|
| + /**
|
| + * The name of the references to be found.
|
| + */
|
| + final String name;
|
| +
|
| + SearchFindMemberReferencesParams(this.name);
|
| +
|
| + factory SearchFindMemberReferencesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + return new SearchFindMemberReferencesParams(name);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences params");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindMemberReferencesParams.fromRequest(Request request) {
|
| + return new SearchFindMemberReferencesParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["name"] = name;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindMemberReferencesParams) {
|
| + return name == other.name;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findMemberReferences result
|
| + *
|
| + * {
|
| + * "id": SearchId
|
| + * }
|
| + */
|
| +class SearchFindMemberReferencesResult {
|
| + /**
|
| + * The identifier used to associate results with this search request.
|
| + */
|
| + final String id;
|
| +
|
| + SearchFindMemberReferencesResult(this.id);
|
| +
|
| + factory SearchFindMemberReferencesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new SearchFindMemberReferencesResult(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findMemberReferences result");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindMemberReferencesResult.fromResponse(Response response) {
|
| + return new SearchFindMemberReferencesResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindMemberReferencesResult) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findTopLevelDeclarations params
|
| + *
|
| + * {
|
| + * "pattern": String
|
| + * }
|
| + */
|
| +class SearchFindTopLevelDeclarationsParams {
|
| + /**
|
| + * The regular expression used to match the names of the declarations to be
|
| + * found.
|
| + */
|
| + final String pattern;
|
| +
|
| + SearchFindTopLevelDeclarationsParams(this.pattern);
|
| +
|
| + factory SearchFindTopLevelDeclarationsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String pattern;
|
| + if (json.containsKey("pattern")) {
|
| + pattern = jsonDecoder._decodeString(jsonPath + ".pattern", json["pattern"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "pattern");
|
| + }
|
| + return new SearchFindTopLevelDeclarationsParams(pattern);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations params");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindTopLevelDeclarationsParams.fromRequest(Request request) {
|
| + return new SearchFindTopLevelDeclarationsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["pattern"] = pattern;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindTopLevelDeclarationsParams) {
|
| + return pattern == other.pattern;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, pattern.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.findTopLevelDeclarations result
|
| + *
|
| + * {
|
| + * "id": SearchId
|
| + * }
|
| + */
|
| +class SearchFindTopLevelDeclarationsResult {
|
| + /**
|
| + * The identifier used to associate results with this search request.
|
| + */
|
| + final String id;
|
| +
|
| + SearchFindTopLevelDeclarationsResult(this.id);
|
| +
|
| + factory SearchFindTopLevelDeclarationsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new SearchFindTopLevelDeclarationsResult(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.findTopLevelDeclarations result");
|
| + }
|
| + }
|
| +
|
| + factory SearchFindTopLevelDeclarationsResult.fromResponse(Response response) {
|
| + return new SearchFindTopLevelDeclarationsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchFindTopLevelDeclarationsResult) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.getTypeHierarchy params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * }
|
| + */
|
| +class SearchGetTypeHierarchyParams {
|
| + /**
|
| + * The file containing the declaration or reference to the type for which a
|
| + * hierarchy is being requested.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the name of the type within the file.
|
| + */
|
| + final int offset;
|
| +
|
| + SearchGetTypeHierarchyParams(this.file, this.offset);
|
| +
|
| + factory SearchGetTypeHierarchyParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new SearchGetTypeHierarchyParams(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy params");
|
| + }
|
| + }
|
| +
|
| + factory SearchGetTypeHierarchyParams.fromRequest(Request request) {
|
| + return new SearchGetTypeHierarchyParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchGetTypeHierarchyParams) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.getTypeHierarchy result
|
| + *
|
| + * {
|
| + * "hierarchyItems": optional List<TypeHierarchyItem>
|
| + * }
|
| + */
|
| +class SearchGetTypeHierarchyResult {
|
| + /**
|
| + * A list of the types in the requested hierarchy. The first element of the
|
| + * list is the item representing the type for which the hierarchy was
|
| + * requested. The index of other elements of the list is unspecified, but
|
| + * correspond to the integers used to reference supertype and subtype items
|
| + * within the items.
|
| + *
|
| + * This field will be absent if the code at the given file and offset does
|
| + * not represent a type, or if the file has not been sufficiently analyzed to
|
| + * allow a type hierarchy to be produced.
|
| + */
|
| + final List<TypeHierarchyItem> hierarchyItems;
|
| +
|
| + SearchGetTypeHierarchyResult({this.hierarchyItems});
|
| +
|
| + factory SearchGetTypeHierarchyResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<TypeHierarchyItem> hierarchyItems;
|
| + if (json.containsKey("hierarchyItems")) {
|
| + hierarchyItems = jsonDecoder._decodeList(jsonPath + ".hierarchyItems", json["hierarchyItems"], (String jsonPath, Object json) => new TypeHierarchyItem.fromJson(jsonDecoder, jsonPath, json));
|
| + }
|
| + return new SearchGetTypeHierarchyResult(hierarchyItems: hierarchyItems);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.getTypeHierarchy result");
|
| + }
|
| + }
|
| +
|
| + factory SearchGetTypeHierarchyResult.fromResponse(Response response) {
|
| + return new SearchGetTypeHierarchyResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + if (hierarchyItems != null) {
|
| + result["hierarchyItems"] = hierarchyItems.map((TypeHierarchyItem value) => value.toJson());
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchGetTypeHierarchyResult) {
|
| + return _listEqual(hierarchyItems, other.hierarchyItems, (TypeHierarchyItem a, TypeHierarchyItem b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, hierarchyItems.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * search.results params
|
| + *
|
| + * {
|
| + * "id": SearchId
|
| + * "results": List<SearchResult>
|
| + * "last": bool
|
| + * }
|
| + */
|
| +class SearchResultsParams {
|
| + /**
|
| + * The id associated with the search.
|
| + */
|
| + final String id;
|
| +
|
| + /**
|
| + * The search results being reported.
|
| + */
|
| + final List<SearchResult> results;
|
| +
|
| + /**
|
| + * True if this is that last set of results that will be returned for the
|
| + * indicated search.
|
| + */
|
| + final bool last;
|
| +
|
| + SearchResultsParams(this.id, this.results, this.last);
|
| +
|
| + factory SearchResultsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + List<SearchResult> results;
|
| + if (json.containsKey("results")) {
|
| + results = jsonDecoder._decodeList(jsonPath + ".results", json["results"], (String jsonPath, Object json) => new SearchResult.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "results");
|
| + }
|
| + bool last;
|
| + if (json.containsKey("last")) {
|
| + last = jsonDecoder._decodeBool(jsonPath + ".last", json["last"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "last");
|
| + }
|
| + return new SearchResultsParams(id, results, last);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "search.results params");
|
| + }
|
| + }
|
| +
|
| + factory SearchResultsParams.fromNotification(Notification notification) {
|
| + return new SearchResultsParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + result["results"] = results.map((SearchResult value) => value.toJson());
|
| + result["last"] = last;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchResultsParams) {
|
| + return id == other.id &&
|
| + _listEqual(results, other.results, (SearchResult a, SearchResult b) => a == b) &&
|
| + last == other.last;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, results.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, last.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getAssists params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * "length": int
|
| + * }
|
| + */
|
| +class EditGetAssistsParams {
|
| + /**
|
| + * The file containing the code for which assists are being requested.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the code for which assists are being requested.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the code for which assists are being requested.
|
| + */
|
| + final int length;
|
| +
|
| + EditGetAssistsParams(this.file, this.offset, this.length);
|
| +
|
| + factory EditGetAssistsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new EditGetAssistsParams(file, offset, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getAssists params");
|
| + }
|
| + }
|
| +
|
| + factory EditGetAssistsParams.fromRequest(Request request) {
|
| + return new EditGetAssistsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetAssistsParams) {
|
| + return file == other.file &&
|
| + offset == other.offset &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getAssists result
|
| + *
|
| + * {
|
| + * "assists": List<SourceChange>
|
| + * }
|
| + */
|
| +class EditGetAssistsResult {
|
| + /**
|
| + * The assists that are available at the given location.
|
| + */
|
| + final List<SourceChange> assists;
|
| +
|
| + EditGetAssistsResult(this.assists);
|
| +
|
| + factory EditGetAssistsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<SourceChange> assists;
|
| + if (json.containsKey("assists")) {
|
| + assists = jsonDecoder._decodeList(jsonPath + ".assists", json["assists"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "assists");
|
| + }
|
| + return new EditGetAssistsResult(assists);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getAssists result");
|
| + }
|
| + }
|
| +
|
| + factory EditGetAssistsResult.fromResponse(Response response) {
|
| + return new EditGetAssistsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["assists"] = assists.map((SourceChange value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetAssistsResult) {
|
| + return _listEqual(assists, other.assists, (SourceChange a, SourceChange b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, assists.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getAvailableRefactorings params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * "length": int
|
| + * }
|
| + */
|
| +class EditGetAvailableRefactoringsParams {
|
| + /**
|
| + * The file containing the code on which the refactoring would be based.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the code on which the refactoring would be based.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the code on which the refactoring would be based.
|
| + */
|
| + final int length;
|
| +
|
| + EditGetAvailableRefactoringsParams(this.file, this.offset, this.length);
|
| +
|
| + factory EditGetAvailableRefactoringsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new EditGetAvailableRefactoringsParams(file, offset, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings params");
|
| + }
|
| + }
|
| +
|
| + factory EditGetAvailableRefactoringsParams.fromRequest(Request request) {
|
| + return new EditGetAvailableRefactoringsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetAvailableRefactoringsParams) {
|
| + return file == other.file &&
|
| + offset == other.offset &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getAvailableRefactorings result
|
| + *
|
| + * {
|
| + * "kinds": List<RefactoringKind>
|
| + * }
|
| + */
|
| +class EditGetAvailableRefactoringsResult {
|
| + /**
|
| + * The kinds of refactorings that are valid for the given selection.
|
| + */
|
| + final List<RefactoringKind> kinds;
|
| +
|
| + EditGetAvailableRefactoringsResult(this.kinds);
|
| +
|
| + factory EditGetAvailableRefactoringsResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<RefactoringKind> kinds;
|
| + if (json.containsKey("kinds")) {
|
| + kinds = jsonDecoder._decodeList(jsonPath + ".kinds", json["kinds"], (String jsonPath, Object json) => new RefactoringKind.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kinds");
|
| + }
|
| + return new EditGetAvailableRefactoringsResult(kinds);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getAvailableRefactorings result");
|
| + }
|
| + }
|
| +
|
| + factory EditGetAvailableRefactoringsResult.fromResponse(Response response) {
|
| + return new EditGetAvailableRefactoringsResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["kinds"] = kinds.map((RefactoringKind value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetAvailableRefactoringsResult) {
|
| + return _listEqual(kinds, other.kinds, (RefactoringKind a, RefactoringKind b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, kinds.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getFixes params
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * }
|
| + */
|
| +class EditGetFixesParams {
|
| + /**
|
| + * The file containing the errors for which fixes are being requested.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset used to select the errors for which fixes will be returned.
|
| + */
|
| + final int offset;
|
| +
|
| + EditGetFixesParams(this.file, this.offset);
|
| +
|
| + factory EditGetFixesParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new EditGetFixesParams(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getFixes params");
|
| + }
|
| + }
|
| +
|
| + factory EditGetFixesParams.fromRequest(Request request) {
|
| + return new EditGetFixesParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetFixesParams) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getFixes result
|
| + *
|
| + * {
|
| + * "fixes": List<ErrorFixes>
|
| + * }
|
| + */
|
| +class EditGetFixesResult {
|
| + /**
|
| + * The fixes that are available for each of the analysis errors. There is a
|
| + * one-to-one correspondence between the analysis errors in the request and
|
| + * the lists of changes in the response. In particular, it is always the case
|
| + * that errors.length == fixes.length and that fixes[i] is the list of fixes
|
| + * for the error in errors[i]. The list of changes corresponding to an error
|
| + * can be empty if there are no fixes available for that error.
|
| + */
|
| + final List<ErrorFixes> fixes;
|
| +
|
| + EditGetFixesResult(this.fixes);
|
| +
|
| + factory EditGetFixesResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<ErrorFixes> fixes;
|
| + if (json.containsKey("fixes")) {
|
| + fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new ErrorFixes.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "fixes");
|
| + }
|
| + return new EditGetFixesResult(fixes);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getFixes result");
|
| + }
|
| + }
|
| +
|
| + factory EditGetFixesResult.fromResponse(Response response) {
|
| + return new EditGetFixesResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["fixes"] = fixes.map((ErrorFixes value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetFixesResult) {
|
| + return _listEqual(fixes, other.fixes, (ErrorFixes a, ErrorFixes b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getRefactoring params
|
| + *
|
| + * {
|
| + * "kindId": RefactoringKind
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * "length": int
|
| + * "validateOnly": bool
|
| + * "options": optional object
|
| + * }
|
| + */
|
| +class EditGetRefactoringParams {
|
| + /**
|
| + * The identifier of the kind of refactoring to be performed.
|
| + */
|
| + final RefactoringKind kindId;
|
| +
|
| + /**
|
| + * The file containing the code involved in the refactoring.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the region involved in the refactoring.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the region involved in the refactoring.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * True if the client is only requesting that the values of the options be
|
| + * validated and no change be generated.
|
| + */
|
| + final bool validateOnly;
|
| +
|
| + /**
|
| + * Data used to provide values provided by the user. The structure of the
|
| + * data is dependent on the kind of refactoring being performed. The data
|
| + * that is expected is documented in the section titled Refactorings, labeled
|
| + * as “Options”. This field can be omitted if the refactoring does not
|
| + * require any options or if the values of those options are not known.
|
| + */
|
| + final Object options;
|
| +
|
| + EditGetRefactoringParams(this.kindId, this.file, this.offset, this.length, this.validateOnly, {this.options});
|
| +
|
| + factory EditGetRefactoringParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + RefactoringKind kindId;
|
| + if (json.containsKey("kindId")) {
|
| + kindId = new RefactoringKind.fromJson(jsonDecoder, jsonPath + ".kindId", json["kindId"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kindId");
|
| + }
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + bool validateOnly;
|
| + if (json.containsKey("validateOnly")) {
|
| + validateOnly = jsonDecoder._decodeBool(jsonPath + ".validateOnly", json["validateOnly"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "validateOnly");
|
| + }
|
| + Object options;
|
| + if (json.containsKey("options")) {
|
| + options = json["options"];
|
| + }
|
| + return new EditGetRefactoringParams(kindId, file, offset, length, validateOnly, options: options);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring params");
|
| + }
|
| + }
|
| +
|
| + factory EditGetRefactoringParams.fromRequest(Request request) {
|
| + return new EditGetRefactoringParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["kindId"] = kindId.toJson();
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + result["validateOnly"] = validateOnly;
|
| + if (options != null) {
|
| + result["options"] = options;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetRefactoringParams) {
|
| + return kindId == other.kindId &&
|
| + file == other.file &&
|
| + offset == other.offset &&
|
| + length == other.length &&
|
| + validateOnly == other.validateOnly &&
|
| + options == other.options;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, kindId.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, validateOnly.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, options.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * edit.getRefactoring result
|
| + *
|
| + * {
|
| + * "status": List<RefactoringProblem>
|
| + * "feedback": optional object
|
| + * "change": optional SourceChange
|
| + * "potentialEdits": optional List<String>
|
| + * }
|
| + */
|
| +class EditGetRefactoringResult {
|
| + /**
|
| + * The status of the refactoring. The array will be empty if there are no
|
| + * known problems.
|
| + */
|
| + final List<RefactoringProblem> status;
|
| +
|
| + /**
|
| + * Data used to provide feedback to the user. The structure of the data is
|
| + * dependent on the kind of refactoring being created. The data that is
|
| + * returned is documented in the section titled Refactorings, labeled as
|
| + * “Feedback”.
|
| + */
|
| + final Object feedback;
|
| +
|
| + /**
|
| + * The changes that are to be applied to affect the refactoring. This field
|
| + * will be omitted if there are problems that prevent a set of changes from
|
| + * being computed, such as having no options specified for a refactoring that
|
| + * requires them, or if only validation was requested.
|
| + */
|
| + final SourceChange change;
|
| +
|
| + /**
|
| + * The ids of source edits that are not known to be valid. An edit is not
|
| + * known to be valid if there was insufficient type information for the
|
| + * server to be able to determine whether or not the code needs to be
|
| + * modified, such as when a member is being renamed and there is a reference
|
| + * to a member from an unknown type. This field will be omitted if the change
|
| + * field is omitted or if there are no potential edits for the refactoring.
|
| + */
|
| + final List<String> potentialEdits;
|
| +
|
| + EditGetRefactoringResult(this.status, {this.feedback, this.change, this.potentialEdits});
|
| +
|
| + factory EditGetRefactoringResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<RefactoringProblem> status;
|
| + if (json.containsKey("status")) {
|
| + status = jsonDecoder._decodeList(jsonPath + ".status", json["status"], (String jsonPath, Object json) => new RefactoringProblem.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "status");
|
| + }
|
| + Object feedback;
|
| + if (json.containsKey("feedback")) {
|
| + feedback = json["feedback"];
|
| + }
|
| + SourceChange change;
|
| + if (json.containsKey("change")) {
|
| + change = new SourceChange.fromJson(jsonDecoder, jsonPath + ".change", json["change"]);
|
| + }
|
| + List<String> potentialEdits;
|
| + if (json.containsKey("potentialEdits")) {
|
| + potentialEdits = jsonDecoder._decodeList(jsonPath + ".potentialEdits", json["potentialEdits"], jsonDecoder._decodeString);
|
| + }
|
| + return new EditGetRefactoringResult(status, feedback: feedback, change: change, potentialEdits: potentialEdits);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "edit.getRefactoring result");
|
| + }
|
| + }
|
| +
|
| + factory EditGetRefactoringResult.fromResponse(Response response) {
|
| + return new EditGetRefactoringResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["status"] = status.map((RefactoringProblem value) => value.toJson());
|
| + if (feedback != null) {
|
| + result["feedback"] = feedback;
|
| + }
|
| + if (change != null) {
|
| + result["change"] = change.toJson();
|
| + }
|
| + if (potentialEdits != null) {
|
| + result["potentialEdits"] = potentialEdits;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is EditGetRefactoringResult) {
|
| + return _listEqual(status, other.status, (RefactoringProblem a, RefactoringProblem b) => a == b) &&
|
| + feedback == other.feedback &&
|
| + change == other.change &&
|
| + _listEqual(potentialEdits, other.potentialEdits, (String a, String b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, status.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, feedback.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, change.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, potentialEdits.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.createContext params
|
| + *
|
| + * {
|
| + * "contextRoot": FilePath
|
| + * }
|
| + */
|
| +class DebugCreateContextParams {
|
| + /**
|
| + * The path of the Dart or HTML file that will be launched.
|
| + */
|
| + final String contextRoot;
|
| +
|
| + DebugCreateContextParams(this.contextRoot);
|
| +
|
| + factory DebugCreateContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String contextRoot;
|
| + if (json.containsKey("contextRoot")) {
|
| + contextRoot = jsonDecoder._decodeString(jsonPath + ".contextRoot", json["contextRoot"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "contextRoot");
|
| + }
|
| + return new DebugCreateContextParams(contextRoot);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.createContext params");
|
| + }
|
| + }
|
| +
|
| + factory DebugCreateContextParams.fromRequest(Request request) {
|
| + return new DebugCreateContextParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["contextRoot"] = contextRoot;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugCreateContextParams) {
|
| + return contextRoot == other.contextRoot;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, contextRoot.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.createContext result
|
| + *
|
| + * {
|
| + * "id": DebugContextId
|
| + * }
|
| + */
|
| +class DebugCreateContextResult {
|
| + /**
|
| + * The identifier used to refer to the debugging context that was created.
|
| + */
|
| + final String id;
|
| +
|
| + DebugCreateContextResult(this.id);
|
| +
|
| + factory DebugCreateContextResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new DebugCreateContextResult(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.createContext result");
|
| + }
|
| + }
|
| +
|
| + factory DebugCreateContextResult.fromResponse(Response response) {
|
| + return new DebugCreateContextResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugCreateContextResult) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.deleteContext params
|
| + *
|
| + * {
|
| + * "id": DebugContextId
|
| + * }
|
| + */
|
| +class DebugDeleteContextParams {
|
| + /**
|
| + * The identifier of the debugging context that is to be deleted.
|
| + */
|
| + final String id;
|
| +
|
| + DebugDeleteContextParams(this.id);
|
| +
|
| + factory DebugDeleteContextParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + return new DebugDeleteContextParams(id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.deleteContext params");
|
| + }
|
| + }
|
| +
|
| + factory DebugDeleteContextParams.fromRequest(Request request) {
|
| + return new DebugDeleteContextParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugDeleteContextParams) {
|
| + return id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.mapUri params
|
| + *
|
| + * {
|
| + * "id": DebugContextId
|
| + * "file": optional FilePath
|
| + * "uri": optional String
|
| + * }
|
| + */
|
| +class DebugMapUriParams {
|
| + /**
|
| + * The identifier of the debugging context in which the URI is to be mapped.
|
| + */
|
| + final String id;
|
| +
|
| + /**
|
| + * The path of the file to be mapped into a URI.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The URI to be mapped into a file path.
|
| + */
|
| + final String uri;
|
| +
|
| + DebugMapUriParams(this.id, {this.file, this.uri});
|
| +
|
| + factory DebugMapUriParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "id");
|
| + }
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + }
|
| + String uri;
|
| + if (json.containsKey("uri")) {
|
| + uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
|
| + }
|
| + return new DebugMapUriParams(id, file: file, uri: uri);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.mapUri params");
|
| + }
|
| + }
|
| +
|
| + factory DebugMapUriParams.fromRequest(Request request) {
|
| + return new DebugMapUriParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["id"] = id;
|
| + if (file != null) {
|
| + result["file"] = file;
|
| + }
|
| + if (uri != null) {
|
| + result["uri"] = uri;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugMapUriParams) {
|
| + return id == other.id &&
|
| + file == other.file &&
|
| + uri == other.uri;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.mapUri result
|
| + *
|
| + * {
|
| + * "file": optional FilePath
|
| + * "uri": optional String
|
| + * }
|
| + */
|
| +class DebugMapUriResult {
|
| + /**
|
| + * The file to which the URI was mapped. This field is omitted if the uri
|
| + * field was not given in the request.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The URI to which the file path was mapped. This field is omitted if the
|
| + * file field was not given in the request.
|
| + */
|
| + final String uri;
|
| +
|
| + DebugMapUriResult({this.file, this.uri});
|
| +
|
| + factory DebugMapUriResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + }
|
| + String uri;
|
| + if (json.containsKey("uri")) {
|
| + uri = jsonDecoder._decodeString(jsonPath + ".uri", json["uri"]);
|
| + }
|
| + return new DebugMapUriResult(file: file, uri: uri);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.mapUri result");
|
| + }
|
| + }
|
| +
|
| + factory DebugMapUriResult.fromResponse(Response response) {
|
| + return new DebugMapUriResult.fromJson(
|
| + new ResponseDecoder(), "result", response.result);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + if (file != null) {
|
| + result["file"] = file;
|
| + }
|
| + if (uri != null) {
|
| + result["uri"] = uri;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugMapUriResult) {
|
| + return file == other.file &&
|
| + uri == other.uri;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, uri.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.setSubscriptions params
|
| + *
|
| + * {
|
| + * "subscriptions": List<DebugService>
|
| + * }
|
| + */
|
| +class DebugSetSubscriptionsParams {
|
| + /**
|
| + * A list of the services being subscribed to.
|
| + */
|
| + final List<DebugService> subscriptions;
|
| +
|
| + DebugSetSubscriptionsParams(this.subscriptions);
|
| +
|
| + factory DebugSetSubscriptionsParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<DebugService> subscriptions;
|
| + if (json.containsKey("subscriptions")) {
|
| + subscriptions = jsonDecoder._decodeList(jsonPath + ".subscriptions", json["subscriptions"], (String jsonPath, Object json) => new DebugService.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "subscriptions");
|
| + }
|
| + return new DebugSetSubscriptionsParams(subscriptions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.setSubscriptions params");
|
| + }
|
| + }
|
| +
|
| + factory DebugSetSubscriptionsParams.fromRequest(Request request) {
|
| + return new DebugSetSubscriptionsParams.fromJson(
|
| + new RequestDecoder(request), "params", request.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["subscriptions"] = subscriptions.map((DebugService value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugSetSubscriptionsParams) {
|
| + return _listEqual(subscriptions, other.subscriptions, (DebugService a, DebugService b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, subscriptions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * debug.launchData params
|
| + *
|
| + * {
|
| + * "executables": List<ExecutableFile>
|
| + * "dartToHtml": Map<FilePath, List<FilePath>>
|
| + * "htmlToDart": Map<FilePath, List<FilePath>>
|
| + * }
|
| + */
|
| +class DebugLaunchDataParams {
|
| + /**
|
| + * A list of the files that are executable in the given context. This list
|
| + * replaces any previous list provided for the given context.
|
| + */
|
| + final List<ExecutableFile> executables;
|
| +
|
| + /**
|
| + * A mapping from the paths of Dart files that are referenced by HTML files
|
| + * to a list of the HTML files that reference the Dart files.
|
| + */
|
| + final Map<String, List<String>> dartToHtml;
|
| +
|
| + /**
|
| + * A mapping from the paths of HTML files that reference Dart files to a list
|
| + * of the Dart files they reference.
|
| + */
|
| + final Map<String, List<String>> htmlToDart;
|
| +
|
| + DebugLaunchDataParams(this.executables, this.dartToHtml, this.htmlToDart);
|
| +
|
| + factory DebugLaunchDataParams.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<ExecutableFile> executables;
|
| + if (json.containsKey("executables")) {
|
| + executables = jsonDecoder._decodeList(jsonPath + ".executables", json["executables"], (String jsonPath, Object json) => new ExecutableFile.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "executables");
|
| + }
|
| + Map<String, List<String>> dartToHtml;
|
| + if (json.containsKey("dartToHtml")) {
|
| + dartToHtml = jsonDecoder._decodeMap(jsonPath + ".dartToHtml", json["dartToHtml"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "dartToHtml");
|
| + }
|
| + Map<String, List<String>> htmlToDart;
|
| + if (json.containsKey("htmlToDart")) {
|
| + htmlToDart = jsonDecoder._decodeMap(jsonPath + ".htmlToDart", json["htmlToDart"], valueDecoder: (String jsonPath, Object json) => jsonDecoder._decodeList(jsonPath, json, jsonDecoder._decodeString));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "htmlToDart");
|
| + }
|
| + return new DebugLaunchDataParams(executables, dartToHtml, htmlToDart);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "debug.launchData params");
|
| + }
|
| + }
|
| +
|
| + factory DebugLaunchDataParams.fromNotification(Notification notification) {
|
| + return new DebugLaunchDataParams.fromJson(
|
| + new ResponseDecoder(), "params", notification.params);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["executables"] = executables.map((ExecutableFile value) => value.toJson());
|
| + result["dartToHtml"] = dartToHtml;
|
| + result["htmlToDart"] = htmlToDart;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is DebugLaunchDataParams) {
|
| + return _listEqual(executables, other.executables, (ExecutableFile a, ExecutableFile b) => a == b) &&
|
| + _mapEqual(dartToHtml, other.dartToHtml, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b)) &&
|
| + _mapEqual(htmlToDart, other.htmlToDart, (List<String> a, List<String> b) => _listEqual(a, b, (String a, String b) => a == b));
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, executables.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, dartToHtml.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, htmlToDart.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * AddContentOverlay
|
| + *
|
| + * {
|
| + * "type": "add"
|
| + * "content": String
|
| + * }
|
| + */
|
| +class AddContentOverlay {
|
| + /**
|
| + * The new content of the file.
|
| + */
|
| + final String content;
|
| +
|
| + AddContentOverlay(this.content);
|
| +
|
| + factory AddContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + if (json["type"] != "add") {
|
| + throw jsonDecoder.mismatch(jsonPath, "equal " + "add");
|
| + }
|
| + String content;
|
| + if (json.containsKey("content")) {
|
| + content = jsonDecoder._decodeString(jsonPath + ".content", json["content"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "content");
|
| + }
|
| + return new AddContentOverlay(content);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "AddContentOverlay");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["type"] = "add";
|
| + result["content"] = content;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AddContentOverlay) {
|
| + return content == other.content;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, 704418402);
|
| + hash = _JenkinsSmiHash.combine(hash, content.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * AnalysisError
|
| + *
|
| + * {
|
| + * "severity": ErrorSeverity
|
| + * "type": ErrorType
|
| + * "location": Location
|
| + * "message": String
|
| + * "correction": optional String
|
| + * }
|
| + */
|
| +class AnalysisError {
|
| + /**
|
| + * The severity of the error.
|
| + */
|
| + final ErrorSeverity severity;
|
| +
|
| + /**
|
| + * The type of the error.
|
| + */
|
| + final ErrorType type;
|
| +
|
| + /**
|
| + * The location associated with the error.
|
| + */
|
| + final Location location;
|
| +
|
| + /**
|
| + * The message to be displayed for this error. The message should indicate
|
| + * what is wrong with the code and why it is wrong.
|
| + */
|
| + final String message;
|
| +
|
| + /**
|
| + * The correction message to be displayed for this error. The correction
|
| + * message should indicate how the user can fix the error. The field is
|
| + * omitted if there is no correction message associated with the error code.
|
| + */
|
| + final String correction;
|
| +
|
| + AnalysisError(this.severity, this.type, this.location, this.message, {this.correction});
|
| +
|
| + factory AnalysisError.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + ErrorSeverity severity;
|
| + if (json.containsKey("severity")) {
|
| + severity = new ErrorSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "severity");
|
| + }
|
| + ErrorType type;
|
| + if (json.containsKey("type")) {
|
| + type = new ErrorType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "type");
|
| + }
|
| + Location location;
|
| + if (json.containsKey("location")) {
|
| + location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "location");
|
| + }
|
| + String message;
|
| + if (json.containsKey("message")) {
|
| + message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "message");
|
| + }
|
| + String correction;
|
| + if (json.containsKey("correction")) {
|
| + correction = jsonDecoder._decodeString(jsonPath + ".correction", json["correction"]);
|
| + }
|
| + return new AnalysisError(severity, type, location, message, correction: correction);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "AnalysisError");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["severity"] = severity.toJson();
|
| + result["type"] = type.toJson();
|
| + result["location"] = location.toJson();
|
| + result["message"] = message;
|
| + if (correction != null) {
|
| + result["correction"] = correction;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisError) {
|
| + return severity == other.severity &&
|
| + type == other.type &&
|
| + location == other.location &&
|
| + message == other.message &&
|
| + correction == other.correction;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, severity.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, type.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, location.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, message.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, correction.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * AnalysisOptions
|
| + *
|
| + * {
|
| + * "enableAsync": optional bool
|
| + * "enableDeferredLoading": optional bool
|
| + * "enableEnums": optional bool
|
| + * "generateDart2jsHints": optional bool
|
| + * "generateHints": optional bool
|
| + * }
|
| + */
|
| +class AnalysisOptions {
|
| + /**
|
| + * True if the client wants to enable support for the proposed async feature.
|
| + */
|
| + final bool enableAsync;
|
| +
|
| + /**
|
| + * True if the client wants to enable support for the proposed deferred
|
| + * loading feature.
|
| + */
|
| + final bool enableDeferredLoading;
|
| +
|
| + /**
|
| + * True if the client wants to enable support for the proposed enum feature.
|
| + */
|
| + final bool enableEnums;
|
| +
|
| + /**
|
| + * True if hints that are specific to dart2js should be generated. This
|
| + * option is ignored if generateHints is false.
|
| + */
|
| + final bool generateDart2jsHints;
|
| +
|
| + /**
|
| + * True is hints should be generated as part of generating errors and
|
| + * warnings.
|
| + */
|
| + final bool generateHints;
|
| +
|
| + AnalysisOptions({this.enableAsync, this.enableDeferredLoading, this.enableEnums, this.generateDart2jsHints, this.generateHints});
|
| +
|
| + factory AnalysisOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + bool enableAsync;
|
| + if (json.containsKey("enableAsync")) {
|
| + enableAsync = jsonDecoder._decodeBool(jsonPath + ".enableAsync", json["enableAsync"]);
|
| + }
|
| + bool enableDeferredLoading;
|
| + if (json.containsKey("enableDeferredLoading")) {
|
| + enableDeferredLoading = jsonDecoder._decodeBool(jsonPath + ".enableDeferredLoading", json["enableDeferredLoading"]);
|
| + }
|
| + bool enableEnums;
|
| + if (json.containsKey("enableEnums")) {
|
| + enableEnums = jsonDecoder._decodeBool(jsonPath + ".enableEnums", json["enableEnums"]);
|
| + }
|
| + bool generateDart2jsHints;
|
| + if (json.containsKey("generateDart2jsHints")) {
|
| + generateDart2jsHints = jsonDecoder._decodeBool(jsonPath + ".generateDart2jsHints", json["generateDart2jsHints"]);
|
| + }
|
| + bool generateHints;
|
| + if (json.containsKey("generateHints")) {
|
| + generateHints = jsonDecoder._decodeBool(jsonPath + ".generateHints", json["generateHints"]);
|
| + }
|
| + return new AnalysisOptions(enableAsync: enableAsync, enableDeferredLoading: enableDeferredLoading, enableEnums: enableEnums, generateDart2jsHints: generateDart2jsHints, generateHints: generateHints);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "AnalysisOptions");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + if (enableAsync != null) {
|
| + result["enableAsync"] = enableAsync;
|
| + }
|
| + if (enableDeferredLoading != null) {
|
| + result["enableDeferredLoading"] = enableDeferredLoading;
|
| + }
|
| + if (enableEnums != null) {
|
| + result["enableEnums"] = enableEnums;
|
| + }
|
| + if (generateDart2jsHints != null) {
|
| + result["generateDart2jsHints"] = generateDart2jsHints;
|
| + }
|
| + if (generateHints != null) {
|
| + result["generateHints"] = generateHints;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisOptions) {
|
| + return enableAsync == other.enableAsync &&
|
| + enableDeferredLoading == other.enableDeferredLoading &&
|
| + enableEnums == other.enableEnums &&
|
| + generateDart2jsHints == other.generateDart2jsHints &&
|
| + generateHints == other.generateHints;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, enableAsync.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, enableDeferredLoading.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, enableEnums.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, generateDart2jsHints.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, generateHints.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * AnalysisService
|
| + *
|
| + * enum {
|
| + * FOLDING
|
| + * HIGHLIGHTS
|
| + * NAVIGATION
|
| + * OCCURRENCES
|
| + * OUTLINE
|
| + * OVERRIDES
|
| + * }
|
| + */
|
| +class AnalysisService {
|
| + static const FOLDING = const AnalysisService._("FOLDING");
|
| +
|
| + static const HIGHLIGHTS = const AnalysisService._("HIGHLIGHTS");
|
| +
|
| + static const NAVIGATION = const AnalysisService._("NAVIGATION");
|
| +
|
| + static const OCCURRENCES = const AnalysisService._("OCCURRENCES");
|
| +
|
| + static const OUTLINE = const AnalysisService._("OUTLINE");
|
| +
|
| + static const OVERRIDES = const AnalysisService._("OVERRIDES");
|
| +
|
| + final String name;
|
| +
|
| + const AnalysisService._(this.name);
|
| +
|
| + factory AnalysisService(String name) {
|
| + switch (name) {
|
| + case "FOLDING":
|
| + return FOLDING;
|
| + case "HIGHLIGHTS":
|
| + return HIGHLIGHTS;
|
| + case "NAVIGATION":
|
| + return NAVIGATION;
|
| + case "OCCURRENCES":
|
| + return OCCURRENCES;
|
| + case "OUTLINE":
|
| + return OUTLINE;
|
| + case "OVERRIDES":
|
| + return OVERRIDES;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory AnalysisService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new AnalysisService(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "AnalysisService");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "AnalysisService.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * AnalysisStatus
|
| + *
|
| + * {
|
| + * "analyzing": bool
|
| + * "analysisTarget": optional String
|
| + * }
|
| + */
|
| +class AnalysisStatus {
|
| + /**
|
| + * True if analysis is currently being performed.
|
| + */
|
| + final bool analyzing;
|
| +
|
| + /**
|
| + * The name of the current target of analysis. This field is omitted if
|
| + * analyzing is false.
|
| + */
|
| + final String analysisTarget;
|
| +
|
| + AnalysisStatus(this.analyzing, {this.analysisTarget});
|
| +
|
| + factory AnalysisStatus.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + bool analyzing;
|
| + if (json.containsKey("analyzing")) {
|
| + analyzing = jsonDecoder._decodeBool(jsonPath + ".analyzing", json["analyzing"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "analyzing");
|
| + }
|
| + String analysisTarget;
|
| + if (json.containsKey("analysisTarget")) {
|
| + analysisTarget = jsonDecoder._decodeString(jsonPath + ".analysisTarget", json["analysisTarget"]);
|
| + }
|
| + return new AnalysisStatus(analyzing, analysisTarget: analysisTarget);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "AnalysisStatus");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["analyzing"] = analyzing;
|
| + if (analysisTarget != null) {
|
| + result["analysisTarget"] = analysisTarget;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is AnalysisStatus) {
|
| + return analyzing == other.analyzing &&
|
| + analysisTarget == other.analysisTarget;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, analyzing.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, analysisTarget.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * ChangeContentOverlay
|
| + *
|
| + * {
|
| + * "type": "change"
|
| + * "edits": List<SourceEdit>
|
| + * }
|
| + */
|
| +class ChangeContentOverlay {
|
| + /**
|
| + * The edits to be applied to the file.
|
| + */
|
| + final List<SourceEdit> edits;
|
| +
|
| + ChangeContentOverlay(this.edits);
|
| +
|
| + factory ChangeContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + if (json["type"] != "change") {
|
| + throw jsonDecoder.mismatch(jsonPath, "equal " + "change");
|
| + }
|
| + List<SourceEdit> edits;
|
| + if (json.containsKey("edits")) {
|
| + edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "edits");
|
| + }
|
| + return new ChangeContentOverlay(edits);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "ChangeContentOverlay");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["type"] = "change";
|
| + result["edits"] = edits.map((SourceEdit value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ChangeContentOverlay) {
|
| + return _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, 873118866);
|
| + hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * CompletionRelevance
|
| + *
|
| + * enum {
|
| + * LOW
|
| + * DEFAULT
|
| + * HIGH
|
| + * }
|
| + */
|
| +class CompletionRelevance {
|
| + static const LOW = const CompletionRelevance._("LOW");
|
| +
|
| + static const DEFAULT = const CompletionRelevance._("DEFAULT");
|
| +
|
| + static const HIGH = const CompletionRelevance._("HIGH");
|
| +
|
| + final String name;
|
| +
|
| + const CompletionRelevance._(this.name);
|
| +
|
| + factory CompletionRelevance(String name) {
|
| + switch (name) {
|
| + case "LOW":
|
| + return LOW;
|
| + case "DEFAULT":
|
| + return DEFAULT;
|
| + case "HIGH":
|
| + return HIGH;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory CompletionRelevance.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new CompletionRelevance(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "CompletionRelevance");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "CompletionRelevance.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * CompletionSuggestion
|
| + *
|
| + * {
|
| + * "kind": CompletionSuggestionKind
|
| + * "relevance": CompletionRelevance
|
| + * "completion": String
|
| + * "selectionOffset": int
|
| + * "selectionLength": int
|
| + * "isDeprecated": bool
|
| + * "isPotential": bool
|
| + * "docSummary": optional String
|
| + * "docComplete": optional String
|
| + * "declaringType": optional String
|
| + * "returnType": optional String
|
| + * "parameterNames": optional List<String>
|
| + * "parameterTypes": optional List<String>
|
| + * "requiredParameterCount": optional int
|
| + * "positionalParameterCount": optional int
|
| + * "parameterName": optional String
|
| + * "parameterType": optional String
|
| + * }
|
| + */
|
| +class CompletionSuggestion {
|
| + /**
|
| + * The kind of element being suggested.
|
| + */
|
| + final CompletionSuggestionKind kind;
|
| +
|
| + /**
|
| + * The relevance of this completion suggestion.
|
| + */
|
| + final CompletionRelevance relevance;
|
| +
|
| + /**
|
| + * The identifier to be inserted if the suggestion is selected. If the
|
| + * suggestion is for a method or function, the client might want to
|
| + * additionally insert a template for the parameters. The information
|
| + * required in order to do so is contained in other fields.
|
| + */
|
| + final String completion;
|
| +
|
| + /**
|
| + * The offset, relative to the beginning of the completion, of where the
|
| + * selection should be placed after insertion.
|
| + */
|
| + final int selectionOffset;
|
| +
|
| + /**
|
| + * The number of characters that should be selected after insertion.
|
| + */
|
| + final int selectionLength;
|
| +
|
| + /**
|
| + * True if the suggested element is deprecated.
|
| + */
|
| + final bool isDeprecated;
|
| +
|
| + /**
|
| + * True if the element is not known to be valid for the target. This happens
|
| + * if the type of the target is dynamic.
|
| + */
|
| + final bool isPotential;
|
| +
|
| + /**
|
| + * An abbreviated version of the Dartdoc associated with the element being
|
| + * suggested, This field is omitted if there is no Dartdoc associated with
|
| + * the element.
|
| + */
|
| + final String docSummary;
|
| +
|
| + /**
|
| + * The Dartdoc associated with the element being suggested, This field is
|
| + * omitted if there is no Dartdoc associated with the element.
|
| + */
|
| + final String docComplete;
|
| +
|
| + /**
|
| + * The class that declares the element being suggested. This field is omitted
|
| + * if the suggested element is not a member of a class.
|
| + */
|
| + final String declaringType;
|
| +
|
| + /**
|
| + * The return type of the getter, function or method being suggested. This
|
| + * field is omitted if the suggested element is not a getter, function or
|
| + * method.
|
| + */
|
| + final String returnType;
|
| +
|
| + /**
|
| + * The names of the parameters of the function or method being suggested.
|
| + * This field is omitted if the suggested element is not a setter, function
|
| + * or method.
|
| + */
|
| + final List<String> parameterNames;
|
| +
|
| + /**
|
| + * The types of the parameters of the function or method being suggested.
|
| + * This field is omitted if the parameterNames field is omitted.
|
| + */
|
| + final List<String> parameterTypes;
|
| +
|
| + /**
|
| + * The number of required parameters for the function or method being
|
| + * suggested. This field is omitted if the parameterNames field is omitted.
|
| + */
|
| + final int requiredParameterCount;
|
| +
|
| + /**
|
| + * The number of positional parameters for the function or method being
|
| + * suggested. This field is omitted if the parameterNames field is omitted.
|
| + */
|
| + final int positionalParameterCount;
|
| +
|
| + /**
|
| + * The name of the optional parameter being suggested. This field is omitted
|
| + * if the suggestion is not the addition of an optional argument within an
|
| + * argument list.
|
| + */
|
| + final String parameterName;
|
| +
|
| + /**
|
| + * The type of the options parameter being suggested. This field is omitted
|
| + * if the parameterName field is omitted.
|
| + */
|
| + final String parameterType;
|
| +
|
| + CompletionSuggestion(this.kind, this.relevance, this.completion, this.selectionOffset, this.selectionLength, this.isDeprecated, this.isPotential, {this.docSummary, this.docComplete, this.declaringType, this.returnType, this.parameterNames, this.parameterTypes, this.requiredParameterCount, this.positionalParameterCount, this.parameterName, this.parameterType});
|
| +
|
| + factory CompletionSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + CompletionSuggestionKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new CompletionSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + CompletionRelevance relevance;
|
| + if (json.containsKey("relevance")) {
|
| + relevance = new CompletionRelevance.fromJson(jsonDecoder, jsonPath + ".relevance", json["relevance"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "relevance");
|
| + }
|
| + String completion;
|
| + if (json.containsKey("completion")) {
|
| + completion = jsonDecoder._decodeString(jsonPath + ".completion", json["completion"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "completion");
|
| + }
|
| + int selectionOffset;
|
| + if (json.containsKey("selectionOffset")) {
|
| + selectionOffset = jsonDecoder._decodeInt(jsonPath + ".selectionOffset", json["selectionOffset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "selectionOffset");
|
| + }
|
| + int selectionLength;
|
| + if (json.containsKey("selectionLength")) {
|
| + selectionLength = jsonDecoder._decodeInt(jsonPath + ".selectionLength", json["selectionLength"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "selectionLength");
|
| + }
|
| + bool isDeprecated;
|
| + if (json.containsKey("isDeprecated")) {
|
| + isDeprecated = jsonDecoder._decodeBool(jsonPath + ".isDeprecated", json["isDeprecated"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "isDeprecated");
|
| + }
|
| + bool isPotential;
|
| + if (json.containsKey("isPotential")) {
|
| + isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["isPotential"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "isPotential");
|
| + }
|
| + String docSummary;
|
| + if (json.containsKey("docSummary")) {
|
| + docSummary = jsonDecoder._decodeString(jsonPath + ".docSummary", json["docSummary"]);
|
| + }
|
| + String docComplete;
|
| + if (json.containsKey("docComplete")) {
|
| + docComplete = jsonDecoder._decodeString(jsonPath + ".docComplete", json["docComplete"]);
|
| + }
|
| + String declaringType;
|
| + if (json.containsKey("declaringType")) {
|
| + declaringType = jsonDecoder._decodeString(jsonPath + ".declaringType", json["declaringType"]);
|
| + }
|
| + String returnType;
|
| + if (json.containsKey("returnType")) {
|
| + returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
|
| + }
|
| + List<String> parameterNames;
|
| + if (json.containsKey("parameterNames")) {
|
| + parameterNames = jsonDecoder._decodeList(jsonPath + ".parameterNames", json["parameterNames"], jsonDecoder._decodeString);
|
| + }
|
| + List<String> parameterTypes;
|
| + if (json.containsKey("parameterTypes")) {
|
| + parameterTypes = jsonDecoder._decodeList(jsonPath + ".parameterTypes", json["parameterTypes"], jsonDecoder._decodeString);
|
| + }
|
| + int requiredParameterCount;
|
| + if (json.containsKey("requiredParameterCount")) {
|
| + requiredParameterCount = jsonDecoder._decodeInt(jsonPath + ".requiredParameterCount", json["requiredParameterCount"]);
|
| + }
|
| + int positionalParameterCount;
|
| + if (json.containsKey("positionalParameterCount")) {
|
| + positionalParameterCount = jsonDecoder._decodeInt(jsonPath + ".positionalParameterCount", json["positionalParameterCount"]);
|
| + }
|
| + String parameterName;
|
| + if (json.containsKey("parameterName")) {
|
| + parameterName = jsonDecoder._decodeString(jsonPath + ".parameterName", json["parameterName"]);
|
| + }
|
| + String parameterType;
|
| + if (json.containsKey("parameterType")) {
|
| + parameterType = jsonDecoder._decodeString(jsonPath + ".parameterType", json["parameterType"]);
|
| + }
|
| + return new CompletionSuggestion(kind, relevance, completion, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary: docSummary, docComplete: docComplete, declaringType: declaringType, returnType: returnType, parameterNames: parameterNames, parameterTypes: parameterTypes, requiredParameterCount: requiredParameterCount, positionalParameterCount: positionalParameterCount, parameterName: parameterName, parameterType: parameterType);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestion");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["kind"] = kind.toJson();
|
| + result["relevance"] = relevance.toJson();
|
| + result["completion"] = completion;
|
| + result["selectionOffset"] = selectionOffset;
|
| + result["selectionLength"] = selectionLength;
|
| + result["isDeprecated"] = isDeprecated;
|
| + result["isPotential"] = isPotential;
|
| + if (docSummary != null) {
|
| + result["docSummary"] = docSummary;
|
| + }
|
| + if (docComplete != null) {
|
| + result["docComplete"] = docComplete;
|
| + }
|
| + if (declaringType != null) {
|
| + result["declaringType"] = declaringType;
|
| + }
|
| + if (returnType != null) {
|
| + result["returnType"] = returnType;
|
| + }
|
| + if (parameterNames != null) {
|
| + result["parameterNames"] = parameterNames;
|
| + }
|
| + if (parameterTypes != null) {
|
| + result["parameterTypes"] = parameterTypes;
|
| + }
|
| + if (requiredParameterCount != null) {
|
| + result["requiredParameterCount"] = requiredParameterCount;
|
| + }
|
| + if (positionalParameterCount != null) {
|
| + result["positionalParameterCount"] = positionalParameterCount;
|
| + }
|
| + if (parameterName != null) {
|
| + result["parameterName"] = parameterName;
|
| + }
|
| + if (parameterType != null) {
|
| + result["parameterType"] = parameterType;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is CompletionSuggestion) {
|
| + return kind == other.kind &&
|
| + relevance == other.relevance &&
|
| + completion == other.completion &&
|
| + selectionOffset == other.selectionOffset &&
|
| + selectionLength == other.selectionLength &&
|
| + isDeprecated == other.isDeprecated &&
|
| + isPotential == other.isPotential &&
|
| + docSummary == other.docSummary &&
|
| + docComplete == other.docComplete &&
|
| + declaringType == other.declaringType &&
|
| + returnType == other.returnType &&
|
| + _listEqual(parameterNames, other.parameterNames, (String a, String b) => a == b) &&
|
| + _listEqual(parameterTypes, other.parameterTypes, (String a, String b) => a == b) &&
|
| + requiredParameterCount == other.requiredParameterCount &&
|
| + positionalParameterCount == other.positionalParameterCount &&
|
| + parameterName == other.parameterName &&
|
| + parameterType == other.parameterType;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, relevance.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, completion.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, selectionOffset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, selectionLength.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, isDeprecated.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, docSummary.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, docComplete.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, declaringType.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameterNames.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameterTypes.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, requiredParameterCount.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, positionalParameterCount.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameterName.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameterType.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * CompletionSuggestionKind
|
| + *
|
| + * enum {
|
| + * ARGUMENT_LIST
|
| + * CLASS
|
| + * CLASS_ALIAS
|
| + * CONSTRUCTOR
|
| + * FIELD
|
| + * FUNCTION
|
| + * FUNCTION_TYPE_ALIAS
|
| + * GETTER
|
| + * IMPORT
|
| + * KEYWORD
|
| + * LIBRARY_PREFIX
|
| + * LOCAL_VARIABLE
|
| + * METHOD
|
| + * METHOD_NAME
|
| + * NAMED_ARGUMENT
|
| + * OPTIONAL_ARGUMENT
|
| + * PARAMETER
|
| + * SETTER
|
| + * TOP_LEVEL_VARIABLE
|
| + * TYPE_PARAMETER
|
| + * }
|
| + */
|
| +class CompletionSuggestionKind {
|
| + static const ARGUMENT_LIST = const CompletionSuggestionKind._("ARGUMENT_LIST");
|
| +
|
| + static const CLASS = const CompletionSuggestionKind._("CLASS");
|
| +
|
| + static const CLASS_ALIAS = const CompletionSuggestionKind._("CLASS_ALIAS");
|
| +
|
| + static const CONSTRUCTOR = const CompletionSuggestionKind._("CONSTRUCTOR");
|
| +
|
| + static const FIELD = const CompletionSuggestionKind._("FIELD");
|
| +
|
| + static const FUNCTION = const CompletionSuggestionKind._("FUNCTION");
|
| +
|
| + static const FUNCTION_TYPE_ALIAS = const CompletionSuggestionKind._("FUNCTION_TYPE_ALIAS");
|
| +
|
| + static const GETTER = const CompletionSuggestionKind._("GETTER");
|
| +
|
| + static const IMPORT = const CompletionSuggestionKind._("IMPORT");
|
| +
|
| + static const KEYWORD = const CompletionSuggestionKind._("KEYWORD");
|
| +
|
| + static const LIBRARY_PREFIX = const CompletionSuggestionKind._("LIBRARY_PREFIX");
|
| +
|
| + static const LOCAL_VARIABLE = const CompletionSuggestionKind._("LOCAL_VARIABLE");
|
| +
|
| + static const METHOD = const CompletionSuggestionKind._("METHOD");
|
| +
|
| + static const METHOD_NAME = const CompletionSuggestionKind._("METHOD_NAME");
|
| +
|
| + static const NAMED_ARGUMENT = const CompletionSuggestionKind._("NAMED_ARGUMENT");
|
| +
|
| + static const OPTIONAL_ARGUMENT = const CompletionSuggestionKind._("OPTIONAL_ARGUMENT");
|
| +
|
| + static const PARAMETER = const CompletionSuggestionKind._("PARAMETER");
|
| +
|
| + static const SETTER = const CompletionSuggestionKind._("SETTER");
|
| +
|
| + static const TOP_LEVEL_VARIABLE = const CompletionSuggestionKind._("TOP_LEVEL_VARIABLE");
|
| +
|
| + static const TYPE_PARAMETER = const CompletionSuggestionKind._("TYPE_PARAMETER");
|
| +
|
| + final String name;
|
| +
|
| + const CompletionSuggestionKind._(this.name);
|
| +
|
| + factory CompletionSuggestionKind(String name) {
|
| + switch (name) {
|
| + case "ARGUMENT_LIST":
|
| + return ARGUMENT_LIST;
|
| + case "CLASS":
|
| + return CLASS;
|
| + case "CLASS_ALIAS":
|
| + return CLASS_ALIAS;
|
| + case "CONSTRUCTOR":
|
| + return CONSTRUCTOR;
|
| + case "FIELD":
|
| + return FIELD;
|
| + case "FUNCTION":
|
| + return FUNCTION;
|
| + case "FUNCTION_TYPE_ALIAS":
|
| + return FUNCTION_TYPE_ALIAS;
|
| + case "GETTER":
|
| + return GETTER;
|
| + case "IMPORT":
|
| + return IMPORT;
|
| + case "KEYWORD":
|
| + return KEYWORD;
|
| + case "LIBRARY_PREFIX":
|
| + return LIBRARY_PREFIX;
|
| + case "LOCAL_VARIABLE":
|
| + return LOCAL_VARIABLE;
|
| + case "METHOD":
|
| + return METHOD;
|
| + case "METHOD_NAME":
|
| + return METHOD_NAME;
|
| + case "NAMED_ARGUMENT":
|
| + return NAMED_ARGUMENT;
|
| + case "OPTIONAL_ARGUMENT":
|
| + return OPTIONAL_ARGUMENT;
|
| + case "PARAMETER":
|
| + return PARAMETER;
|
| + case "SETTER":
|
| + return SETTER;
|
| + case "TOP_LEVEL_VARIABLE":
|
| + return TOP_LEVEL_VARIABLE;
|
| + case "TYPE_PARAMETER":
|
| + return TYPE_PARAMETER;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory CompletionSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new CompletionSuggestionKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "CompletionSuggestionKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "CompletionSuggestionKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * DebugService
|
| + *
|
| + * enum {
|
| + * LAUNCH_DATA
|
| + * }
|
| + */
|
| +class DebugService {
|
| + static const LAUNCH_DATA = const DebugService._("LAUNCH_DATA");
|
| +
|
| + final String name;
|
| +
|
| + const DebugService._(this.name);
|
| +
|
| + factory DebugService(String name) {
|
| + switch (name) {
|
| + case "LAUNCH_DATA":
|
| + return LAUNCH_DATA;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory DebugService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new DebugService(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "DebugService");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "DebugService.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * Element
|
| + *
|
| + * {
|
| + * "kind": ElementKind
|
| + * "name": String
|
| + * "location": optional Location
|
| + * "flags": int
|
| + * "parameters": optional String
|
| + * "returnType": optional String
|
| + * }
|
| + */
|
| +class Element {
|
| + /**
|
| + * The kind of the element.
|
| + */
|
| + final ElementKind kind;
|
| +
|
| + /**
|
| + * The name of the element. This is typically used as the label in the
|
| + * outline.
|
| + */
|
| + final String name;
|
| +
|
| + /**
|
| + * The location of the name in the declaration of the element.
|
| + */
|
| + final Location location;
|
| +
|
| + /**
|
| + * A bit-map containing the following flags:
|
| + *
|
| + * - 0x01 - set if the element is explicitly or implicitly abstract
|
| + * - 0x02 - set if the element was declared to be ‘const’
|
| + * - 0x04 - set if the element was declared to be ‘final’
|
| + * - 0x08 - set if the element is a static member of a class or is a
|
| + * top-level function or field
|
| + * - 0x10 - set if the element is private
|
| + * - 0x20 - set if the element is deprecated
|
| + */
|
| + final int flags;
|
| +
|
| + /**
|
| + * The parameter list for the element. If the element is not a method or
|
| + * function this field will not be defined. If the element has zero
|
| + * parameters, this field will have a value of "()".
|
| + */
|
| + final String parameters;
|
| +
|
| + /**
|
| + * The return type of the element. If the element is not a method or function
|
| + * this field will not be defined. If the element does not have a declared
|
| + * return type, this field will contain an empty string.
|
| + */
|
| + final String returnType;
|
| +
|
| + Element(this.kind, this.name, this.flags, {this.location, this.parameters, this.returnType});
|
| +
|
| + factory Element.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + ElementKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new ElementKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + Location location;
|
| + if (json.containsKey("location")) {
|
| + location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
|
| + }
|
| + int flags;
|
| + if (json.containsKey("flags")) {
|
| + flags = jsonDecoder._decodeInt(jsonPath + ".flags", json["flags"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "flags");
|
| + }
|
| + String parameters;
|
| + if (json.containsKey("parameters")) {
|
| + parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["parameters"]);
|
| + }
|
| + String returnType;
|
| + if (json.containsKey("returnType")) {
|
| + returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
|
| + }
|
| + return new Element(kind, name, flags, location: location, parameters: parameters, returnType: returnType);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Element");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["kind"] = kind.toJson();
|
| + result["name"] = name;
|
| + if (location != null) {
|
| + result["location"] = location.toJson();
|
| + }
|
| + result["flags"] = flags;
|
| + if (parameters != null) {
|
| + result["parameters"] = parameters;
|
| + }
|
| + if (returnType != null) {
|
| + result["returnType"] = returnType;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Element) {
|
| + return kind == other.kind &&
|
| + name == other.name &&
|
| + location == other.location &&
|
| + flags == other.flags &&
|
| + parameters == other.parameters &&
|
| + returnType == other.returnType;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, location.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, flags.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * ElementKind
|
| + *
|
| + * enum {
|
| + * CLASS
|
| + * CLASS_TYPE_ALIAS
|
| + * COMPILATION_UNIT
|
| + * CONSTRUCTOR
|
| + * FIELD
|
| + * FUNCTION
|
| + * FUNCTION_TYPE_ALIAS
|
| + * GETTER
|
| + * LIBRARY
|
| + * LOCAL_VARIABLE
|
| + * METHOD
|
| + * PARAMETER
|
| + * SETTER
|
| + * TOP_LEVEL_VARIABLE
|
| + * TYPE_PARAMETER
|
| + * UNIT_TEST_GROUP
|
| + * UNIT_TEST_TEST
|
| + * UNKNOWN
|
| + * }
|
| + */
|
| +class ElementKind {
|
| + static const CLASS = const ElementKind._("CLASS");
|
| +
|
| + static const CLASS_TYPE_ALIAS = const ElementKind._("CLASS_TYPE_ALIAS");
|
| +
|
| + static const COMPILATION_UNIT = const ElementKind._("COMPILATION_UNIT");
|
| +
|
| + static const CONSTRUCTOR = const ElementKind._("CONSTRUCTOR");
|
| +
|
| + static const FIELD = const ElementKind._("FIELD");
|
| +
|
| + static const FUNCTION = const ElementKind._("FUNCTION");
|
| +
|
| + static const FUNCTION_TYPE_ALIAS = const ElementKind._("FUNCTION_TYPE_ALIAS");
|
| +
|
| + static const GETTER = const ElementKind._("GETTER");
|
| +
|
| + static const LIBRARY = const ElementKind._("LIBRARY");
|
| +
|
| + static const LOCAL_VARIABLE = const ElementKind._("LOCAL_VARIABLE");
|
| +
|
| + static const METHOD = const ElementKind._("METHOD");
|
| +
|
| + static const PARAMETER = const ElementKind._("PARAMETER");
|
| +
|
| + static const SETTER = const ElementKind._("SETTER");
|
| +
|
| + static const TOP_LEVEL_VARIABLE = const ElementKind._("TOP_LEVEL_VARIABLE");
|
| +
|
| + static const TYPE_PARAMETER = const ElementKind._("TYPE_PARAMETER");
|
| +
|
| + static const UNIT_TEST_GROUP = const ElementKind._("UNIT_TEST_GROUP");
|
| +
|
| + static const UNIT_TEST_TEST = const ElementKind._("UNIT_TEST_TEST");
|
| +
|
| + static const UNKNOWN = const ElementKind._("UNKNOWN");
|
| +
|
| + final String name;
|
| +
|
| + const ElementKind._(this.name);
|
| +
|
| + factory ElementKind(String name) {
|
| + switch (name) {
|
| + case "CLASS":
|
| + return CLASS;
|
| + case "CLASS_TYPE_ALIAS":
|
| + return CLASS_TYPE_ALIAS;
|
| + case "COMPILATION_UNIT":
|
| + return COMPILATION_UNIT;
|
| + case "CONSTRUCTOR":
|
| + return CONSTRUCTOR;
|
| + case "FIELD":
|
| + return FIELD;
|
| + case "FUNCTION":
|
| + return FUNCTION;
|
| + case "FUNCTION_TYPE_ALIAS":
|
| + return FUNCTION_TYPE_ALIAS;
|
| + case "GETTER":
|
| + return GETTER;
|
| + case "LIBRARY":
|
| + return LIBRARY;
|
| + case "LOCAL_VARIABLE":
|
| + return LOCAL_VARIABLE;
|
| + case "METHOD":
|
| + return METHOD;
|
| + case "PARAMETER":
|
| + return PARAMETER;
|
| + case "SETTER":
|
| + return SETTER;
|
| + case "TOP_LEVEL_VARIABLE":
|
| + return TOP_LEVEL_VARIABLE;
|
| + case "TYPE_PARAMETER":
|
| + return TYPE_PARAMETER;
|
| + case "UNIT_TEST_GROUP":
|
| + return UNIT_TEST_GROUP;
|
| + case "UNIT_TEST_TEST":
|
| + return UNIT_TEST_TEST;
|
| + case "UNKNOWN":
|
| + return UNKNOWN;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory ElementKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new ElementKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "ElementKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "ElementKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * Error
|
| + *
|
| + * {
|
| + * "code": String
|
| + * "message": String
|
| + * "data": optional object
|
| + * }
|
| + */
|
| +class Error {
|
| + /**
|
| + * A code that uniquely identifies the error that occurred.
|
| + */
|
| + final String code;
|
| +
|
| + /**
|
| + * A short description of the error.
|
| + */
|
| + final String message;
|
| +
|
| + /**
|
| + * Additional data related to the error. This field is omitted if there is no
|
| + * additional data available.
|
| + */
|
| + final Object data;
|
| +
|
| + Error(this.code, this.message, {this.data});
|
| +
|
| + factory Error.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String code;
|
| + if (json.containsKey("code")) {
|
| + code = jsonDecoder._decodeString(jsonPath + ".code", json["code"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "code");
|
| + }
|
| + String message;
|
| + if (json.containsKey("message")) {
|
| + message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "message");
|
| + }
|
| + Object data;
|
| + if (json.containsKey("data")) {
|
| + data = json["data"];
|
| + }
|
| + return new Error(code, message, data: data);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Error");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["code"] = code;
|
| + result["message"] = message;
|
| + if (data != null) {
|
| + result["data"] = data;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Error) {
|
| + return code == other.code &&
|
| + message == other.message &&
|
| + data == other.data;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, code.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, message.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, data.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * ErrorFixes
|
| + *
|
| + * {
|
| + * "error": AnalysisError
|
| + * "fixes": List<SourceChange>
|
| + * }
|
| + */
|
| +class ErrorFixes {
|
| + /**
|
| + * The error with which the fixes are associated.
|
| + */
|
| + final AnalysisError error;
|
| +
|
| + /**
|
| + * The fixes associated with the error.
|
| + */
|
| + final List<SourceChange> fixes;
|
| +
|
| + ErrorFixes(this.error, this.fixes);
|
| +
|
| + factory ErrorFixes.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + AnalysisError error;
|
| + if (json.containsKey("error")) {
|
| + error = new AnalysisError.fromJson(jsonDecoder, jsonPath + ".error", json["error"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "error");
|
| + }
|
| + List<SourceChange> fixes;
|
| + if (json.containsKey("fixes")) {
|
| + fixes = jsonDecoder._decodeList(jsonPath + ".fixes", json["fixes"], (String jsonPath, Object json) => new SourceChange.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "fixes");
|
| + }
|
| + return new ErrorFixes(error, fixes);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "ErrorFixes");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["error"] = error.toJson();
|
| + result["fixes"] = fixes.map((SourceChange value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ErrorFixes) {
|
| + return error == other.error &&
|
| + _listEqual(fixes, other.fixes, (SourceChange a, SourceChange b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, error.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, fixes.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * ErrorSeverity
|
| + *
|
| + * enum {
|
| + * INFO
|
| + * WARNING
|
| + * ERROR
|
| + * }
|
| + */
|
| +class ErrorSeverity {
|
| + static const INFO = const ErrorSeverity._("INFO");
|
| +
|
| + static const WARNING = const ErrorSeverity._("WARNING");
|
| +
|
| + static const ERROR = const ErrorSeverity._("ERROR");
|
| +
|
| + final String name;
|
| +
|
| + const ErrorSeverity._(this.name);
|
| +
|
| + factory ErrorSeverity(String name) {
|
| + switch (name) {
|
| + case "INFO":
|
| + return INFO;
|
| + case "WARNING":
|
| + return WARNING;
|
| + case "ERROR":
|
| + return ERROR;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory ErrorSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new ErrorSeverity(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "ErrorSeverity");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "ErrorSeverity.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * ErrorType
|
| + *
|
| + * enum {
|
| + * COMPILE_TIME_ERROR
|
| + * HINT
|
| + * STATIC_TYPE_WARNING
|
| + * STATIC_WARNING
|
| + * SYNTACTIC_ERROR
|
| + * TODO
|
| + * }
|
| + */
|
| +class ErrorType {
|
| + static const COMPILE_TIME_ERROR = const ErrorType._("COMPILE_TIME_ERROR");
|
| +
|
| + static const HINT = const ErrorType._("HINT");
|
| +
|
| + static const STATIC_TYPE_WARNING = const ErrorType._("STATIC_TYPE_WARNING");
|
| +
|
| + static const STATIC_WARNING = const ErrorType._("STATIC_WARNING");
|
| +
|
| + static const SYNTACTIC_ERROR = const ErrorType._("SYNTACTIC_ERROR");
|
| +
|
| + static const TODO = const ErrorType._("TODO");
|
| +
|
| + final String name;
|
| +
|
| + const ErrorType._(this.name);
|
| +
|
| + factory ErrorType(String name) {
|
| + switch (name) {
|
| + case "COMPILE_TIME_ERROR":
|
| + return COMPILE_TIME_ERROR;
|
| + case "HINT":
|
| + return HINT;
|
| + case "STATIC_TYPE_WARNING":
|
| + return STATIC_TYPE_WARNING;
|
| + case "STATIC_WARNING":
|
| + return STATIC_WARNING;
|
| + case "SYNTACTIC_ERROR":
|
| + return SYNTACTIC_ERROR;
|
| + case "TODO":
|
| + return TODO;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory ErrorType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new ErrorType(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "ErrorType");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "ErrorType.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * ExecutableFile
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": ExecutableKind
|
| + * }
|
| + */
|
| +class ExecutableFile {
|
| + /**
|
| + * The path of the executable file.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the region to be highlighted.
|
| + */
|
| + final ExecutableKind offset;
|
| +
|
| + ExecutableFile(this.file, this.offset);
|
| +
|
| + factory ExecutableFile.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + ExecutableKind offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = new ExecutableKind.fromJson(jsonDecoder, jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new ExecutableFile(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "ExecutableFile");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ExecutableFile) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * ExecutableKind
|
| + *
|
| + * enum {
|
| + * CLIENT
|
| + * EITHER
|
| + * SERVER
|
| + * }
|
| + */
|
| +class ExecutableKind {
|
| + static const CLIENT = const ExecutableKind._("CLIENT");
|
| +
|
| + static const EITHER = const ExecutableKind._("EITHER");
|
| +
|
| + static const SERVER = const ExecutableKind._("SERVER");
|
| +
|
| + final String name;
|
| +
|
| + const ExecutableKind._(this.name);
|
| +
|
| + factory ExecutableKind(String name) {
|
| + switch (name) {
|
| + case "CLIENT":
|
| + return CLIENT;
|
| + case "EITHER":
|
| + return EITHER;
|
| + case "SERVER":
|
| + return SERVER;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory ExecutableKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new ExecutableKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "ExecutableKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "ExecutableKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * FoldingKind
|
| + *
|
| + * enum {
|
| + * COMMENT
|
| + * CLASS_MEMBER
|
| + * DIRECTIVES
|
| + * DOCUMENTATION_COMMENT
|
| + * TOP_LEVEL_DECLARATION
|
| + * }
|
| + */
|
| +class FoldingKind {
|
| + static const COMMENT = const FoldingKind._("COMMENT");
|
| +
|
| + static const CLASS_MEMBER = const FoldingKind._("CLASS_MEMBER");
|
| +
|
| + static const DIRECTIVES = const FoldingKind._("DIRECTIVES");
|
| +
|
| + static const DOCUMENTATION_COMMENT = const FoldingKind._("DOCUMENTATION_COMMENT");
|
| +
|
| + static const TOP_LEVEL_DECLARATION = const FoldingKind._("TOP_LEVEL_DECLARATION");
|
| +
|
| + final String name;
|
| +
|
| + const FoldingKind._(this.name);
|
| +
|
| + factory FoldingKind(String name) {
|
| + switch (name) {
|
| + case "COMMENT":
|
| + return COMMENT;
|
| + case "CLASS_MEMBER":
|
| + return CLASS_MEMBER;
|
| + case "DIRECTIVES":
|
| + return DIRECTIVES;
|
| + case "DOCUMENTATION_COMMENT":
|
| + return DOCUMENTATION_COMMENT;
|
| + case "TOP_LEVEL_DECLARATION":
|
| + return TOP_LEVEL_DECLARATION;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory FoldingKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new FoldingKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "FoldingKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "FoldingKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * FoldingRegion
|
| + *
|
| + * {
|
| + * "kind": FoldingKind
|
| + * "offset": int
|
| + * "length": int
|
| + * }
|
| + */
|
| +class FoldingRegion {
|
| + /**
|
| + * The kind of the region.
|
| + */
|
| + final FoldingKind kind;
|
| +
|
| + /**
|
| + * The offset of the region to be folded.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the region to be folded.
|
| + */
|
| + final int length;
|
| +
|
| + FoldingRegion(this.kind, this.offset, this.length);
|
| +
|
| + factory FoldingRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + FoldingKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new FoldingKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new FoldingRegion(kind, offset, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "FoldingRegion");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["kind"] = kind.toJson();
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is FoldingRegion) {
|
| + return kind == other.kind &&
|
| + offset == other.offset &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * HighlightRegion
|
| + *
|
| + * {
|
| + * "type": HighlightRegionType
|
| + * "offset": int
|
| + * "length": int
|
| + * }
|
| + */
|
| +class HighlightRegion {
|
| + /**
|
| + * The type of highlight associated with the region.
|
| + */
|
| + final HighlightRegionType type;
|
| +
|
| + /**
|
| + * The offset of the region to be highlighted.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the region to be highlighted.
|
| + */
|
| + final int length;
|
| +
|
| + HighlightRegion(this.type, this.offset, this.length);
|
| +
|
| + factory HighlightRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + HighlightRegionType type;
|
| + if (json.containsKey("type")) {
|
| + type = new HighlightRegionType.fromJson(jsonDecoder, jsonPath + ".type", json["type"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "type");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new HighlightRegion(type, offset, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "HighlightRegion");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["type"] = type.toJson();
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is HighlightRegion) {
|
| + return type == other.type &&
|
| + offset == other.offset &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, type.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * HighlightRegionType
|
| + *
|
| + * enum {
|
| + * ANNOTATION
|
| + * BUILT_IN
|
| + * CLASS
|
| + * COMMENT_BLOCK
|
| + * COMMENT_DOCUMENTATION
|
| + * COMMENT_END_OF_LINE
|
| + * CONSTRUCTOR
|
| + * DIRECTIVE
|
| + * DYNAMIC_TYPE
|
| + * FIELD
|
| + * FIELD_STATIC
|
| + * FUNCTION
|
| + * FUNCTION_DECLARATION
|
| + * FUNCTION_TYPE_ALIAS
|
| + * GETTER_DECLARATION
|
| + * IDENTIFIER_DEFAULT
|
| + * IMPORT_PREFIX
|
| + * KEYWORD
|
| + * LITERAL_BOOLEAN
|
| + * LITERAL_DOUBLE
|
| + * LITERAL_INTEGER
|
| + * LITERAL_LIST
|
| + * LITERAL_MAP
|
| + * LITERAL_STRING
|
| + * LOCAL_VARIABLE
|
| + * LOCAL_VARIABLE_DECLARATION
|
| + * METHOD
|
| + * METHOD_DECLARATION
|
| + * METHOD_DECLARATION_STATIC
|
| + * METHOD_STATIC
|
| + * PARAMETER
|
| + * SETTER_DECLARATION
|
| + * TOP_LEVEL_VARIABLE
|
| + * TYPE_NAME_DYNAMIC
|
| + * TYPE_PARAMETER
|
| + * }
|
| + */
|
| +class HighlightRegionType {
|
| + static const ANNOTATION = const HighlightRegionType._("ANNOTATION");
|
| +
|
| + static const BUILT_IN = const HighlightRegionType._("BUILT_IN");
|
| +
|
| + static const CLASS = const HighlightRegionType._("CLASS");
|
| +
|
| + static const COMMENT_BLOCK = const HighlightRegionType._("COMMENT_BLOCK");
|
| +
|
| + static const COMMENT_DOCUMENTATION = const HighlightRegionType._("COMMENT_DOCUMENTATION");
|
| +
|
| + static const COMMENT_END_OF_LINE = const HighlightRegionType._("COMMENT_END_OF_LINE");
|
| +
|
| + static const CONSTRUCTOR = const HighlightRegionType._("CONSTRUCTOR");
|
| +
|
| + static const DIRECTIVE = const HighlightRegionType._("DIRECTIVE");
|
| +
|
| + static const DYNAMIC_TYPE = const HighlightRegionType._("DYNAMIC_TYPE");
|
| +
|
| + static const FIELD = const HighlightRegionType._("FIELD");
|
| +
|
| + static const FIELD_STATIC = const HighlightRegionType._("FIELD_STATIC");
|
| +
|
| + static const FUNCTION = const HighlightRegionType._("FUNCTION");
|
| +
|
| + static const FUNCTION_DECLARATION = const HighlightRegionType._("FUNCTION_DECLARATION");
|
| +
|
| + static const FUNCTION_TYPE_ALIAS = const HighlightRegionType._("FUNCTION_TYPE_ALIAS");
|
| +
|
| + static const GETTER_DECLARATION = const HighlightRegionType._("GETTER_DECLARATION");
|
| +
|
| + static const IDENTIFIER_DEFAULT = const HighlightRegionType._("IDENTIFIER_DEFAULT");
|
| +
|
| + static const IMPORT_PREFIX = const HighlightRegionType._("IMPORT_PREFIX");
|
| +
|
| + static const KEYWORD = const HighlightRegionType._("KEYWORD");
|
| +
|
| + static const LITERAL_BOOLEAN = const HighlightRegionType._("LITERAL_BOOLEAN");
|
| +
|
| + static const LITERAL_DOUBLE = const HighlightRegionType._("LITERAL_DOUBLE");
|
| +
|
| + static const LITERAL_INTEGER = const HighlightRegionType._("LITERAL_INTEGER");
|
| +
|
| + static const LITERAL_LIST = const HighlightRegionType._("LITERAL_LIST");
|
| +
|
| + static const LITERAL_MAP = const HighlightRegionType._("LITERAL_MAP");
|
| +
|
| + static const LITERAL_STRING = const HighlightRegionType._("LITERAL_STRING");
|
| +
|
| + static const LOCAL_VARIABLE = const HighlightRegionType._("LOCAL_VARIABLE");
|
| +
|
| + static const LOCAL_VARIABLE_DECLARATION = const HighlightRegionType._("LOCAL_VARIABLE_DECLARATION");
|
| +
|
| + static const METHOD = const HighlightRegionType._("METHOD");
|
| +
|
| + static const METHOD_DECLARATION = const HighlightRegionType._("METHOD_DECLARATION");
|
| +
|
| + static const METHOD_DECLARATION_STATIC = const HighlightRegionType._("METHOD_DECLARATION_STATIC");
|
| +
|
| + static const METHOD_STATIC = const HighlightRegionType._("METHOD_STATIC");
|
| +
|
| + static const PARAMETER = const HighlightRegionType._("PARAMETER");
|
| +
|
| + static const SETTER_DECLARATION = const HighlightRegionType._("SETTER_DECLARATION");
|
| +
|
| + static const TOP_LEVEL_VARIABLE = const HighlightRegionType._("TOP_LEVEL_VARIABLE");
|
| +
|
| + static const TYPE_NAME_DYNAMIC = const HighlightRegionType._("TYPE_NAME_DYNAMIC");
|
| +
|
| + static const TYPE_PARAMETER = const HighlightRegionType._("TYPE_PARAMETER");
|
| +
|
| + final String name;
|
| +
|
| + const HighlightRegionType._(this.name);
|
| +
|
| + factory HighlightRegionType(String name) {
|
| + switch (name) {
|
| + case "ANNOTATION":
|
| + return ANNOTATION;
|
| + case "BUILT_IN":
|
| + return BUILT_IN;
|
| + case "CLASS":
|
| + return CLASS;
|
| + case "COMMENT_BLOCK":
|
| + return COMMENT_BLOCK;
|
| + case "COMMENT_DOCUMENTATION":
|
| + return COMMENT_DOCUMENTATION;
|
| + case "COMMENT_END_OF_LINE":
|
| + return COMMENT_END_OF_LINE;
|
| + case "CONSTRUCTOR":
|
| + return CONSTRUCTOR;
|
| + case "DIRECTIVE":
|
| + return DIRECTIVE;
|
| + case "DYNAMIC_TYPE":
|
| + return DYNAMIC_TYPE;
|
| + case "FIELD":
|
| + return FIELD;
|
| + case "FIELD_STATIC":
|
| + return FIELD_STATIC;
|
| + case "FUNCTION":
|
| + return FUNCTION;
|
| + case "FUNCTION_DECLARATION":
|
| + return FUNCTION_DECLARATION;
|
| + case "FUNCTION_TYPE_ALIAS":
|
| + return FUNCTION_TYPE_ALIAS;
|
| + case "GETTER_DECLARATION":
|
| + return GETTER_DECLARATION;
|
| + case "IDENTIFIER_DEFAULT":
|
| + return IDENTIFIER_DEFAULT;
|
| + case "IMPORT_PREFIX":
|
| + return IMPORT_PREFIX;
|
| + case "KEYWORD":
|
| + return KEYWORD;
|
| + case "LITERAL_BOOLEAN":
|
| + return LITERAL_BOOLEAN;
|
| + case "LITERAL_DOUBLE":
|
| + return LITERAL_DOUBLE;
|
| + case "LITERAL_INTEGER":
|
| + return LITERAL_INTEGER;
|
| + case "LITERAL_LIST":
|
| + return LITERAL_LIST;
|
| + case "LITERAL_MAP":
|
| + return LITERAL_MAP;
|
| + case "LITERAL_STRING":
|
| + return LITERAL_STRING;
|
| + case "LOCAL_VARIABLE":
|
| + return LOCAL_VARIABLE;
|
| + case "LOCAL_VARIABLE_DECLARATION":
|
| + return LOCAL_VARIABLE_DECLARATION;
|
| + case "METHOD":
|
| + return METHOD;
|
| + case "METHOD_DECLARATION":
|
| + return METHOD_DECLARATION;
|
| + case "METHOD_DECLARATION_STATIC":
|
| + return METHOD_DECLARATION_STATIC;
|
| + case "METHOD_STATIC":
|
| + return METHOD_STATIC;
|
| + case "PARAMETER":
|
| + return PARAMETER;
|
| + case "SETTER_DECLARATION":
|
| + return SETTER_DECLARATION;
|
| + case "TOP_LEVEL_VARIABLE":
|
| + return TOP_LEVEL_VARIABLE;
|
| + case "TYPE_NAME_DYNAMIC":
|
| + return TYPE_NAME_DYNAMIC;
|
| + case "TYPE_PARAMETER":
|
| + return TYPE_PARAMETER;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory HighlightRegionType.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new HighlightRegionType(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "HighlightRegionType");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "HighlightRegionType.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * HoverInformation
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * "containingLibraryPath": optional String
|
| + * "containingLibraryName": optional String
|
| + * "dartdoc": optional String
|
| + * "elementDescription": optional String
|
| + * "elementKind": optional String
|
| + * "parameter": optional String
|
| + * "propagatedType": optional String
|
| + * "staticType": optional String
|
| + * }
|
| + */
|
| +class HoverInformation {
|
| + /**
|
| + * The offset of the range of characters that encompases the cursor position
|
| + * and has the same hover information as the cursor position.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the range of characters that encompases the cursor position
|
| + * and has the same hover information as the cursor position.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The path to the defining compilation unit of the library in which the
|
| + * referenced element is declared. This data is omitted if there is no
|
| + * referenced element.
|
| + */
|
| + final String containingLibraryPath;
|
| +
|
| + /**
|
| + * The name of the library in which the referenced element is declared. This
|
| + * data is omitted if there is no referenced element.
|
| + */
|
| + final String containingLibraryName;
|
| +
|
| + /**
|
| + * The dartdoc associated with the referenced element. Other than the removal
|
| + * of the comment delimiters, including leading asterisks in the case of a
|
| + * block comment, the dartdoc is unprocessed markdown. This data is omitted
|
| + * if there is no referenced element.
|
| + */
|
| + final String dartdoc;
|
| +
|
| + /**
|
| + * A human-readable description of the element being referenced. This data is
|
| + * omitted if there is no referenced element.
|
| + */
|
| + final String elementDescription;
|
| +
|
| + /**
|
| + * A human-readable description of the kind of element being referenced (such
|
| + * as “class” or “function type alias”). This data is omitted if there is no
|
| + * referenced element.
|
| + */
|
| + final String elementKind;
|
| +
|
| + /**
|
| + * A human-readable description of the parameter corresponding to the
|
| + * expression being hovered over. This data is omitted if the location is not
|
| + * in an argument to a function.
|
| + */
|
| + final String parameter;
|
| +
|
| + /**
|
| + * The name of the propagated type of the expression. This data is omitted if
|
| + * the location does not correspond to an expression or if there is no
|
| + * propagated type information.
|
| + */
|
| + final String propagatedType;
|
| +
|
| + /**
|
| + * The name of the static type of the expression. This data is omitted if the
|
| + * location does not correspond to an expression.
|
| + */
|
| + final String staticType;
|
| +
|
| + HoverInformation(this.offset, this.length, {this.containingLibraryPath, this.containingLibraryName, this.dartdoc, this.elementDescription, this.elementKind, this.parameter, this.propagatedType, this.staticType});
|
| +
|
| + factory HoverInformation.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + String containingLibraryPath;
|
| + if (json.containsKey("containingLibraryPath")) {
|
| + containingLibraryPath = jsonDecoder._decodeString(jsonPath + ".containingLibraryPath", json["containingLibraryPath"]);
|
| + }
|
| + String containingLibraryName;
|
| + if (json.containsKey("containingLibraryName")) {
|
| + containingLibraryName = jsonDecoder._decodeString(jsonPath + ".containingLibraryName", json["containingLibraryName"]);
|
| + }
|
| + String dartdoc;
|
| + if (json.containsKey("dartdoc")) {
|
| + dartdoc = jsonDecoder._decodeString(jsonPath + ".dartdoc", json["dartdoc"]);
|
| + }
|
| + String elementDescription;
|
| + if (json.containsKey("elementDescription")) {
|
| + elementDescription = jsonDecoder._decodeString(jsonPath + ".elementDescription", json["elementDescription"]);
|
| + }
|
| + String elementKind;
|
| + if (json.containsKey("elementKind")) {
|
| + elementKind = jsonDecoder._decodeString(jsonPath + ".elementKind", json["elementKind"]);
|
| + }
|
| + String parameter;
|
| + if (json.containsKey("parameter")) {
|
| + parameter = jsonDecoder._decodeString(jsonPath + ".parameter", json["parameter"]);
|
| + }
|
| + String propagatedType;
|
| + if (json.containsKey("propagatedType")) {
|
| + propagatedType = jsonDecoder._decodeString(jsonPath + ".propagatedType", json["propagatedType"]);
|
| + }
|
| + String staticType;
|
| + if (json.containsKey("staticType")) {
|
| + staticType = jsonDecoder._decodeString(jsonPath + ".staticType", json["staticType"]);
|
| + }
|
| + return new HoverInformation(offset, length, containingLibraryPath: containingLibraryPath, containingLibraryName: containingLibraryName, dartdoc: dartdoc, elementDescription: elementDescription, elementKind: elementKind, parameter: parameter, propagatedType: propagatedType, staticType: staticType);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "HoverInformation");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + if (containingLibraryPath != null) {
|
| + result["containingLibraryPath"] = containingLibraryPath;
|
| + }
|
| + if (containingLibraryName != null) {
|
| + result["containingLibraryName"] = containingLibraryName;
|
| + }
|
| + if (dartdoc != null) {
|
| + result["dartdoc"] = dartdoc;
|
| + }
|
| + if (elementDescription != null) {
|
| + result["elementDescription"] = elementDescription;
|
| + }
|
| + if (elementKind != null) {
|
| + result["elementKind"] = elementKind;
|
| + }
|
| + if (parameter != null) {
|
| + result["parameter"] = parameter;
|
| + }
|
| + if (propagatedType != null) {
|
| + result["propagatedType"] = propagatedType;
|
| + }
|
| + if (staticType != null) {
|
| + result["staticType"] = staticType;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is HoverInformation) {
|
| + return offset == other.offset &&
|
| + length == other.length &&
|
| + containingLibraryPath == other.containingLibraryPath &&
|
| + containingLibraryName == other.containingLibraryName &&
|
| + dartdoc == other.dartdoc &&
|
| + elementDescription == other.elementDescription &&
|
| + elementKind == other.elementKind &&
|
| + parameter == other.parameter &&
|
| + propagatedType == other.propagatedType &&
|
| + staticType == other.staticType;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, containingLibraryPath.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, containingLibraryName.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, dartdoc.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, elementDescription.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, elementKind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameter.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, propagatedType.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, staticType.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * LinkedEditGroup
|
| + *
|
| + * {
|
| + * "positions": List<Position>
|
| + * "length": int
|
| + * "suggestions": List<LinkedEditSuggestion>
|
| + * }
|
| + */
|
| +class LinkedEditGroup {
|
| + /**
|
| + * The positions of the regions that should be edited simultaneously.
|
| + */
|
| + final List<Position> positions;
|
| +
|
| + /**
|
| + * The length of the regions that should be edited simultaneously.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * Pre-computed suggestions for what every region might want to be changed
|
| + * to.
|
| + */
|
| + final List<LinkedEditSuggestion> suggestions;
|
| +
|
| + LinkedEditGroup(this.positions, this.length, this.suggestions);
|
| +
|
| + factory LinkedEditGroup.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<Position> positions;
|
| + if (json.containsKey("positions")) {
|
| + positions = jsonDecoder._decodeList(jsonPath + ".positions", json["positions"], (String jsonPath, Object json) => new Position.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "positions");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + List<LinkedEditSuggestion> suggestions;
|
| + if (json.containsKey("suggestions")) {
|
| + suggestions = jsonDecoder._decodeList(jsonPath + ".suggestions", json["suggestions"], (String jsonPath, Object json) => new LinkedEditSuggestion.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "suggestions");
|
| + }
|
| + return new LinkedEditGroup(positions, length, suggestions);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "LinkedEditGroup");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["positions"] = positions.map((Position value) => value.toJson());
|
| + result["length"] = length;
|
| + result["suggestions"] = suggestions.map((LinkedEditSuggestion value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is LinkedEditGroup) {
|
| + return _listEqual(positions, other.positions, (Position a, Position b) => a == b) &&
|
| + length == other.length &&
|
| + _listEqual(suggestions, other.suggestions, (LinkedEditSuggestion a, LinkedEditSuggestion b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, positions.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, suggestions.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * LinkedEditSuggestion
|
| + *
|
| + * {
|
| + * "value": String
|
| + * "kind": LinkedEditSuggestionKind
|
| + * }
|
| + */
|
| +class LinkedEditSuggestion {
|
| + /**
|
| + * The value that could be used to replace all of the linked edit regions.
|
| + */
|
| + final String value;
|
| +
|
| + /**
|
| + * The kind of value being proposed.
|
| + */
|
| + final LinkedEditSuggestionKind kind;
|
| +
|
| + LinkedEditSuggestion(this.value, this.kind);
|
| +
|
| + factory LinkedEditSuggestion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String value;
|
| + if (json.containsKey("value")) {
|
| + value = jsonDecoder._decodeString(jsonPath + ".value", json["value"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "value");
|
| + }
|
| + LinkedEditSuggestionKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new LinkedEditSuggestionKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + return new LinkedEditSuggestion(value, kind);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestion");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["value"] = value;
|
| + result["kind"] = kind.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is LinkedEditSuggestion) {
|
| + return value == other.value &&
|
| + kind == other.kind;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, value.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * LinkedEditSuggestionKind
|
| + *
|
| + * enum {
|
| + * METHOD
|
| + * PARAMETER
|
| + * TYPE
|
| + * VARIABLE
|
| + * }
|
| + */
|
| +class LinkedEditSuggestionKind {
|
| + static const METHOD = const LinkedEditSuggestionKind._("METHOD");
|
| +
|
| + static const PARAMETER = const LinkedEditSuggestionKind._("PARAMETER");
|
| +
|
| + static const TYPE = const LinkedEditSuggestionKind._("TYPE");
|
| +
|
| + static const VARIABLE = const LinkedEditSuggestionKind._("VARIABLE");
|
| +
|
| + final String name;
|
| +
|
| + const LinkedEditSuggestionKind._(this.name);
|
| +
|
| + factory LinkedEditSuggestionKind(String name) {
|
| + switch (name) {
|
| + case "METHOD":
|
| + return METHOD;
|
| + case "PARAMETER":
|
| + return PARAMETER;
|
| + case "TYPE":
|
| + return TYPE;
|
| + case "VARIABLE":
|
| + return VARIABLE;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory LinkedEditSuggestionKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new LinkedEditSuggestionKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "LinkedEditSuggestionKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "LinkedEditSuggestionKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * Location
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * "length": int
|
| + * "startLine": int
|
| + * "startColumn": int
|
| + * }
|
| + */
|
| +class Location {
|
| + /**
|
| + * The file containing the range.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the range.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the range.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The one-based index of the line containing the first character of the
|
| + * range.
|
| + */
|
| + final int startLine;
|
| +
|
| + /**
|
| + * The one-based index of the column containing the first character of the
|
| + * range.
|
| + */
|
| + final int startColumn;
|
| +
|
| + Location(this.file, this.offset, this.length, this.startLine, this.startColumn);
|
| +
|
| + factory Location.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + int startLine;
|
| + if (json.containsKey("startLine")) {
|
| + startLine = jsonDecoder._decodeInt(jsonPath + ".startLine", json["startLine"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "startLine");
|
| + }
|
| + int startColumn;
|
| + if (json.containsKey("startColumn")) {
|
| + startColumn = jsonDecoder._decodeInt(jsonPath + ".startColumn", json["startColumn"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "startColumn");
|
| + }
|
| + return new Location(file, offset, length, startLine, startColumn);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Location");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + result["startLine"] = startLine;
|
| + result["startColumn"] = startColumn;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Location) {
|
| + return file == other.file &&
|
| + offset == other.offset &&
|
| + length == other.length &&
|
| + startLine == other.startLine &&
|
| + startColumn == other.startColumn;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, startLine.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, startColumn.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * NavigationRegion
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * "targets": List<Element>
|
| + * }
|
| + */
|
| +class NavigationRegion {
|
| + /**
|
| + * The offset of the region from which the user can navigate.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the region from which the user can navigate.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The elements to which the given region is bound. By opening the
|
| + * declaration of the elements, clients can implement one form of navigation.
|
| + */
|
| + final List<Element> targets;
|
| +
|
| + NavigationRegion(this.offset, this.length, this.targets);
|
| +
|
| + factory NavigationRegion.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + List<Element> targets;
|
| + if (json.containsKey("targets")) {
|
| + targets = jsonDecoder._decodeList(jsonPath + ".targets", json["targets"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "targets");
|
| + }
|
| + return new NavigationRegion(offset, length, targets);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "NavigationRegion");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + result["targets"] = targets.map((Element value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is NavigationRegion) {
|
| + return offset == other.offset &&
|
| + length == other.length &&
|
| + _listEqual(targets, other.targets, (Element a, Element b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, targets.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * Occurrences
|
| + *
|
| + * {
|
| + * "element": Element
|
| + * "offsets": List<int>
|
| + * "length": int
|
| + * }
|
| + */
|
| +class Occurrences {
|
| + /**
|
| + * The element that was referenced.
|
| + */
|
| + final Element element;
|
| +
|
| + /**
|
| + * The offsets of the name of the referenced element within the file.
|
| + */
|
| + final List<int> offsets;
|
| +
|
| + /**
|
| + * The length of the name of the referenced element.
|
| + */
|
| + final int length;
|
| +
|
| + Occurrences(this.element, this.offsets, this.length);
|
| +
|
| + factory Occurrences.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Element element;
|
| + if (json.containsKey("element")) {
|
| + element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "element");
|
| + }
|
| + List<int> offsets;
|
| + if (json.containsKey("offsets")) {
|
| + offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offsets");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new Occurrences(element, offsets, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Occurrences");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["element"] = element.toJson();
|
| + result["offsets"] = offsets;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Occurrences) {
|
| + return element == other.element &&
|
| + _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, element.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * Outline
|
| + *
|
| + * {
|
| + * "element": Element
|
| + * "offset": int
|
| + * "length": int
|
| + * "children": optional List<Outline>
|
| + * }
|
| + */
|
| +class Outline {
|
| + /**
|
| + * A description of the element represented by this node.
|
| + */
|
| + final Element element;
|
| +
|
| + /**
|
| + * The offset of the first character of the element. This is different than
|
| + * the offset in the Element, which if the offset of the name of the element.
|
| + * It can be used, for example, to map locations in the file back to an
|
| + * outline.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the element.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The children of the node. The field will be omitted if the node has no
|
| + * children.
|
| + */
|
| + final List<Outline> children;
|
| +
|
| + Outline(this.element, this.offset, this.length, {this.children});
|
| +
|
| + factory Outline.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Element element;
|
| + if (json.containsKey("element")) {
|
| + element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "element");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + List<Outline> children;
|
| + if (json.containsKey("children")) {
|
| + children = jsonDecoder._decodeList(jsonPath + ".children", json["children"], (String jsonPath, Object json) => new Outline.fromJson(jsonDecoder, jsonPath, json));
|
| + }
|
| + return new Outline(element, offset, length, children: children);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Outline");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["element"] = element.toJson();
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + if (children != null) {
|
| + result["children"] = children.map((Outline value) => value.toJson());
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Outline) {
|
| + return element == other.element &&
|
| + offset == other.offset &&
|
| + length == other.length &&
|
| + _listEqual(children, other.children, (Outline a, Outline b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, element.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, children.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * Override
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * "superclassMember": optional OverriddenMember
|
| + * "interfaceMembers": optional List<OverriddenMember>
|
| + * }
|
| + */
|
| +class Override {
|
| + /**
|
| + * The offset of the name of the overriding member.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the name of the overriding member.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The member inherited from a superclass that is overridden by the
|
| + * overriding member. The field is omitted if there is no superclass member,
|
| + * in which case there must be at least one interface member.
|
| + */
|
| + final OverriddenMember superclassMember;
|
| +
|
| + /**
|
| + * The members inherited from interfaces that are overridden by the
|
| + * overriding member. The field is omitted if there are no interface members,
|
| + * in which case there must be a superclass member.
|
| + */
|
| + final List<OverriddenMember> interfaceMembers;
|
| +
|
| + Override(this.offset, this.length, {this.superclassMember, this.interfaceMembers});
|
| +
|
| + factory Override.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + OverriddenMember superclassMember;
|
| + if (json.containsKey("superclassMember")) {
|
| + superclassMember = new OverriddenMember.fromJson(jsonDecoder, jsonPath + ".superclassMember", json["superclassMember"]);
|
| + }
|
| + List<OverriddenMember> interfaceMembers;
|
| + if (json.containsKey("interfaceMembers")) {
|
| + interfaceMembers = jsonDecoder._decodeList(jsonPath + ".interfaceMembers", json["interfaceMembers"], (String jsonPath, Object json) => new OverriddenMember.fromJson(jsonDecoder, jsonPath, json));
|
| + }
|
| + return new Override(offset, length, superclassMember: superclassMember, interfaceMembers: interfaceMembers);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Override");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + if (superclassMember != null) {
|
| + result["superclassMember"] = superclassMember.toJson();
|
| + }
|
| + if (interfaceMembers != null) {
|
| + result["interfaceMembers"] = interfaceMembers.map((OverriddenMember value) => value.toJson());
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Override) {
|
| + return offset == other.offset &&
|
| + length == other.length &&
|
| + superclassMember == other.superclassMember &&
|
| + _listEqual(interfaceMembers, other.interfaceMembers, (OverriddenMember a, OverriddenMember b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, superclassMember.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, interfaceMembers.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * OverriddenMember
|
| + *
|
| + * {
|
| + * "element": Element
|
| + * "className": String
|
| + * }
|
| + */
|
| +class OverriddenMember {
|
| + /**
|
| + * The element that is being overridden.
|
| + */
|
| + final Element element;
|
| +
|
| + /**
|
| + * The name of the class in which the member is defined.
|
| + */
|
| + final String className;
|
| +
|
| + OverriddenMember(this.element, this.className);
|
| +
|
| + factory OverriddenMember.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Element element;
|
| + if (json.containsKey("element")) {
|
| + element = new Element.fromJson(jsonDecoder, jsonPath + ".element", json["element"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "element");
|
| + }
|
| + String className;
|
| + if (json.containsKey("className")) {
|
| + className = jsonDecoder._decodeString(jsonPath + ".className", json["className"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "className");
|
| + }
|
| + return new OverriddenMember(element, className);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "OverriddenMember");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["element"] = element.toJson();
|
| + result["className"] = className;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is OverriddenMember) {
|
| + return element == other.element &&
|
| + className == other.className;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, element.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, className.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * Position
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "offset": int
|
| + * }
|
| + */
|
| +class Position {
|
| + /**
|
| + * The file containing the position.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * The offset of the position.
|
| + */
|
| + final int offset;
|
| +
|
| + Position(this.file, this.offset);
|
| +
|
| + factory Position.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + return new Position(file, offset);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "Position");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["offset"] = offset;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is Position) {
|
| + return file == other.file &&
|
| + offset == other.offset;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * RefactoringKind
|
| + *
|
| + * enum {
|
| + * CONVERT_GETTER_TO_METHOD
|
| + * CONVERT_METHOD_TO_GETTER
|
| + * EXTRACT_LOCAL_VARIABLE
|
| + * EXTRACT_METHOD
|
| + * INLINE_LOCAL_VARIABLE
|
| + * INLINE_METHOD
|
| + * RENAME
|
| + * }
|
| + */
|
| +class RefactoringKind {
|
| + static const CONVERT_GETTER_TO_METHOD = const RefactoringKind._("CONVERT_GETTER_TO_METHOD");
|
| +
|
| + static const CONVERT_METHOD_TO_GETTER = const RefactoringKind._("CONVERT_METHOD_TO_GETTER");
|
| +
|
| + static const EXTRACT_LOCAL_VARIABLE = const RefactoringKind._("EXTRACT_LOCAL_VARIABLE");
|
| +
|
| + static const EXTRACT_METHOD = const RefactoringKind._("EXTRACT_METHOD");
|
| +
|
| + static const INLINE_LOCAL_VARIABLE = const RefactoringKind._("INLINE_LOCAL_VARIABLE");
|
| +
|
| + static const INLINE_METHOD = const RefactoringKind._("INLINE_METHOD");
|
| +
|
| + static const RENAME = const RefactoringKind._("RENAME");
|
| +
|
| + final String name;
|
| +
|
| + const RefactoringKind._(this.name);
|
| +
|
| + factory RefactoringKind(String name) {
|
| + switch (name) {
|
| + case "CONVERT_GETTER_TO_METHOD":
|
| + return CONVERT_GETTER_TO_METHOD;
|
| + case "CONVERT_METHOD_TO_GETTER":
|
| + return CONVERT_METHOD_TO_GETTER;
|
| + case "EXTRACT_LOCAL_VARIABLE":
|
| + return EXTRACT_LOCAL_VARIABLE;
|
| + case "EXTRACT_METHOD":
|
| + return EXTRACT_METHOD;
|
| + case "INLINE_LOCAL_VARIABLE":
|
| + return INLINE_LOCAL_VARIABLE;
|
| + case "INLINE_METHOD":
|
| + return INLINE_METHOD;
|
| + case "RENAME":
|
| + return RENAME;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory RefactoringKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new RefactoringKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "RefactoringKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "RefactoringKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * RefactoringMethodParameter
|
| + *
|
| + * {
|
| + * "id": optional String
|
| + * "kind": RefactoringMethodParameterKind
|
| + * "type": String
|
| + * "name": String
|
| + * "parameters": optional String
|
| + * }
|
| + */
|
| +class RefactoringMethodParameter {
|
| + /**
|
| + * The unique identifier of the parameter. Clients may omit this field for
|
| + * the parameters they want to add.
|
| + */
|
| + final String id;
|
| +
|
| + /**
|
| + * The kind of the parameter.
|
| + */
|
| + final RefactoringMethodParameterKind kind;
|
| +
|
| + /**
|
| + * The type that should be given to the parameter, or the return type of the
|
| + * parameter's function type.
|
| + */
|
| + final String type;
|
| +
|
| + /**
|
| + * The name that should be given to the parameter.
|
| + */
|
| + final String name;
|
| +
|
| + /**
|
| + * The parameter list of the parameter's function type. If the parameter is
|
| + * not of a function type, this field will not be defined. If the function
|
| + * type has zero parameters, this field will have a value of "()".
|
| + */
|
| + final String parameters;
|
| +
|
| + RefactoringMethodParameter(this.kind, this.type, this.name, {this.id, this.parameters});
|
| +
|
| + factory RefactoringMethodParameter.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + }
|
| + RefactoringMethodParameterKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new RefactoringMethodParameterKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + String type;
|
| + if (json.containsKey("type")) {
|
| + type = jsonDecoder._decodeString(jsonPath + ".type", json["type"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "type");
|
| + }
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + String parameters;
|
| + if (json.containsKey("parameters")) {
|
| + parameters = jsonDecoder._decodeString(jsonPath + ".parameters", json["parameters"]);
|
| + }
|
| + return new RefactoringMethodParameter(kind, type, name, id: id, parameters: parameters);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameter");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + if (id != null) {
|
| + result["id"] = id;
|
| + }
|
| + result["kind"] = kind.toJson();
|
| + result["type"] = type;
|
| + result["name"] = name;
|
| + if (parameters != null) {
|
| + result["parameters"] = parameters;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is RefactoringMethodParameter) {
|
| + return id == other.id &&
|
| + kind == other.kind &&
|
| + type == other.type &&
|
| + name == other.name &&
|
| + parameters == other.parameters;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, type.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * RefactoringMethodParameterKind
|
| + *
|
| + * enum {
|
| + * REQUIRED
|
| + * POSITIONAL
|
| + * NAMED
|
| + * }
|
| + */
|
| +class RefactoringMethodParameterKind {
|
| + static const REQUIRED = const RefactoringMethodParameterKind._("REQUIRED");
|
| +
|
| + static const POSITIONAL = const RefactoringMethodParameterKind._("POSITIONAL");
|
| +
|
| + static const NAMED = const RefactoringMethodParameterKind._("NAMED");
|
| +
|
| + final String name;
|
| +
|
| + const RefactoringMethodParameterKind._(this.name);
|
| +
|
| + factory RefactoringMethodParameterKind(String name) {
|
| + switch (name) {
|
| + case "REQUIRED":
|
| + return REQUIRED;
|
| + case "POSITIONAL":
|
| + return POSITIONAL;
|
| + case "NAMED":
|
| + return NAMED;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory RefactoringMethodParameterKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new RefactoringMethodParameterKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "RefactoringMethodParameterKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "RefactoringMethodParameterKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * RefactoringProblem
|
| + *
|
| + * {
|
| + * "severity": RefactoringProblemSeverity
|
| + * "message": String
|
| + * "location": Location
|
| + * }
|
| + */
|
| +class RefactoringProblem {
|
| + /**
|
| + * The severity of the problem being represented.
|
| + */
|
| + final RefactoringProblemSeverity severity;
|
| +
|
| + /**
|
| + * A human-readable description of the problem being represented.
|
| + */
|
| + final String message;
|
| +
|
| + /**
|
| + * The location of the problem being represented.
|
| + */
|
| + final Location location;
|
| +
|
| + RefactoringProblem(this.severity, this.message, this.location);
|
| +
|
| + factory RefactoringProblem.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + RefactoringProblemSeverity severity;
|
| + if (json.containsKey("severity")) {
|
| + severity = new RefactoringProblemSeverity.fromJson(jsonDecoder, jsonPath + ".severity", json["severity"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "severity");
|
| + }
|
| + String message;
|
| + if (json.containsKey("message")) {
|
| + message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "message");
|
| + }
|
| + Location location;
|
| + if (json.containsKey("location")) {
|
| + location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "location");
|
| + }
|
| + return new RefactoringProblem(severity, message, location);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "RefactoringProblem");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["severity"] = severity.toJson();
|
| + result["message"] = message;
|
| + result["location"] = location.toJson();
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is RefactoringProblem) {
|
| + return severity == other.severity &&
|
| + message == other.message &&
|
| + location == other.location;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, severity.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, message.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, location.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * RefactoringProblemSeverity
|
| + *
|
| + * enum {
|
| + * INFO
|
| + * WARNING
|
| + * ERROR
|
| + * FATAL
|
| + * }
|
| + */
|
| +class RefactoringProblemSeverity {
|
| + static const INFO = const RefactoringProblemSeverity._("INFO");
|
| +
|
| + static const WARNING = const RefactoringProblemSeverity._("WARNING");
|
| +
|
| + static const ERROR = const RefactoringProblemSeverity._("ERROR");
|
| +
|
| + static const FATAL = const RefactoringProblemSeverity._("FATAL");
|
| +
|
| + final String name;
|
| +
|
| + const RefactoringProblemSeverity._(this.name);
|
| +
|
| + factory RefactoringProblemSeverity(String name) {
|
| + switch (name) {
|
| + case "INFO":
|
| + return INFO;
|
| + case "WARNING":
|
| + return WARNING;
|
| + case "ERROR":
|
| + return ERROR;
|
| + case "FATAL":
|
| + return FATAL;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory RefactoringProblemSeverity.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new RefactoringProblemSeverity(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "RefactoringProblemSeverity");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "RefactoringProblemSeverity.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * RemoveContentOverlay
|
| + *
|
| + * {
|
| + * "type": "remove"
|
| + * }
|
| + */
|
| +class RemoveContentOverlay {
|
| + RemoveContentOverlay();
|
| +
|
| + factory RemoveContentOverlay.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + if (json["type"] != "remove") {
|
| + throw jsonDecoder.mismatch(jsonPath, "equal " + "remove");
|
| + }
|
| + return new RemoveContentOverlay();
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "RemoveContentOverlay");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["type"] = "remove";
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is RemoveContentOverlay) {
|
| + return true;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, 114870849);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * SearchResult
|
| + *
|
| + * {
|
| + * "location": Location
|
| + * "kind": SearchResultKind
|
| + * "isPotential": bool
|
| + * "path": List<Element>
|
| + * }
|
| + */
|
| +class SearchResult {
|
| + /**
|
| + * The location of the code that matched the search criteria.
|
| + */
|
| + final Location location;
|
| +
|
| + /**
|
| + * The kind of element that was found or the kind of reference that was
|
| + * found.
|
| + */
|
| + final SearchResultKind kind;
|
| +
|
| + /**
|
| + * True if the result is a potential match but cannot be confirmed to be a
|
| + * match. For example, if all references to a method m defined in some class
|
| + * were requested, and a reference to a method m from an unknown class were
|
| + * found, it would be marked as being a potential match.
|
| + */
|
| + final bool isPotential;
|
| +
|
| + /**
|
| + * The elements that contain the result, starting with the most immediately
|
| + * enclosing ancestor and ending with the library.
|
| + */
|
| + final List<Element> path;
|
| +
|
| + SearchResult(this.location, this.kind, this.isPotential, this.path);
|
| +
|
| + factory SearchResult.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Location location;
|
| + if (json.containsKey("location")) {
|
| + location = new Location.fromJson(jsonDecoder, jsonPath + ".location", json["location"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "location");
|
| + }
|
| + SearchResultKind kind;
|
| + if (json.containsKey("kind")) {
|
| + kind = new SearchResultKind.fromJson(jsonDecoder, jsonPath + ".kind", json["kind"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "kind");
|
| + }
|
| + bool isPotential;
|
| + if (json.containsKey("isPotential")) {
|
| + isPotential = jsonDecoder._decodeBool(jsonPath + ".isPotential", json["isPotential"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "isPotential");
|
| + }
|
| + List<Element> path;
|
| + if (json.containsKey("path")) {
|
| + path = jsonDecoder._decodeList(jsonPath + ".path", json["path"], (String jsonPath, Object json) => new Element.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "path");
|
| + }
|
| + return new SearchResult(location, kind, isPotential, path);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "SearchResult");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["location"] = location.toJson();
|
| + result["kind"] = kind.toJson();
|
| + result["isPotential"] = isPotential;
|
| + result["path"] = path.map((Element value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SearchResult) {
|
| + return location == other.location &&
|
| + kind == other.kind &&
|
| + isPotential == other.isPotential &&
|
| + _listEqual(path, other.path, (Element a, Element b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, location.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, kind.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, isPotential.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, path.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * SearchResultKind
|
| + *
|
| + * enum {
|
| + * DECLARATION
|
| + * INVOCATION
|
| + * READ
|
| + * READ_WRITE
|
| + * REFERENCE
|
| + * WRITE
|
| + * }
|
| + */
|
| +class SearchResultKind {
|
| + /**
|
| + * The declaration of an element.
|
| + */
|
| + static const DECLARATION = const SearchResultKind._("DECLARATION");
|
| +
|
| + /**
|
| + * The invocation of a function or method.
|
| + */
|
| + static const INVOCATION = const SearchResultKind._("INVOCATION");
|
| +
|
| + /**
|
| + * A reference to a field, parameter or variable where it is being read.
|
| + */
|
| + static const READ = const SearchResultKind._("READ");
|
| +
|
| + /**
|
| + * A reference to a field, parameter or variable where it is being read and
|
| + * written.
|
| + */
|
| + static const READ_WRITE = const SearchResultKind._("READ_WRITE");
|
| +
|
| + /**
|
| + * A reference to an element.
|
| + */
|
| + static const REFERENCE = const SearchResultKind._("REFERENCE");
|
| +
|
| + /**
|
| + * A reference to a field, parameter or variable where it is being written.
|
| + */
|
| + static const WRITE = const SearchResultKind._("WRITE");
|
| +
|
| + final String name;
|
| +
|
| + const SearchResultKind._(this.name);
|
| +
|
| + factory SearchResultKind(String name) {
|
| + switch (name) {
|
| + case "DECLARATION":
|
| + return DECLARATION;
|
| + case "INVOCATION":
|
| + return INVOCATION;
|
| + case "READ":
|
| + return READ;
|
| + case "READ_WRITE":
|
| + return READ_WRITE;
|
| + case "REFERENCE":
|
| + return REFERENCE;
|
| + case "WRITE":
|
| + return WRITE;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory SearchResultKind.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new SearchResultKind(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "SearchResultKind");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "SearchResultKind.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * ServerService
|
| + *
|
| + * enum {
|
| + * STATUS
|
| + * }
|
| + */
|
| +class ServerService {
|
| + static const STATUS = const ServerService._("STATUS");
|
| +
|
| + final String name;
|
| +
|
| + const ServerService._(this.name);
|
| +
|
| + factory ServerService(String name) {
|
| + switch (name) {
|
| + case "STATUS":
|
| + return STATUS;
|
| + }
|
| + throw new Exception('Illegal enum value: $name');
|
| + }
|
| +
|
| + factory ServerService.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is String) {
|
| + try {
|
| + return new ServerService(json);
|
| + } catch(_) {
|
| + // Fall through
|
| + }
|
| + }
|
| + throw jsonDecoder.mismatch(jsonPath, "ServerService");
|
| + }
|
| +
|
| + @override
|
| + String toString() => "ServerService.$name";
|
| +
|
| + String toJson() => name;
|
| +}
|
| +
|
| +/**
|
| + * SourceChange
|
| + *
|
| + * {
|
| + * "message": String
|
| + * "edits": List<SourceFileEdit>
|
| + * "linkedEditGroups": List<LinkedEditGroup>
|
| + * "selection": optional Position
|
| + * }
|
| + */
|
| +class SourceChange {
|
| + /**
|
| + * A human-readable description of the change to be applied.
|
| + */
|
| + final String message;
|
| +
|
| + /**
|
| + * A list of the edits used to effect the change, grouped by file.
|
| + */
|
| + final List<SourceFileEdit> edits;
|
| +
|
| + /**
|
| + * A list of the linked editing groups used to customize the changes that
|
| + * were made.
|
| + */
|
| + final List<LinkedEditGroup> linkedEditGroups;
|
| +
|
| + /**
|
| + * The position that should be selected after the edits have been applied.
|
| + */
|
| + final Position selection;
|
| +
|
| + SourceChange(this.message, this.edits, this.linkedEditGroups, {this.selection});
|
| +
|
| + factory SourceChange.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String message;
|
| + if (json.containsKey("message")) {
|
| + message = jsonDecoder._decodeString(jsonPath + ".message", json["message"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "message");
|
| + }
|
| + List<SourceFileEdit> edits;
|
| + if (json.containsKey("edits")) {
|
| + edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceFileEdit.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "edits");
|
| + }
|
| + List<LinkedEditGroup> linkedEditGroups;
|
| + if (json.containsKey("linkedEditGroups")) {
|
| + linkedEditGroups = jsonDecoder._decodeList(jsonPath + ".linkedEditGroups", json["linkedEditGroups"], (String jsonPath, Object json) => new LinkedEditGroup.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "linkedEditGroups");
|
| + }
|
| + Position selection;
|
| + if (json.containsKey("selection")) {
|
| + selection = new Position.fromJson(jsonDecoder, jsonPath + ".selection", json["selection"]);
|
| + }
|
| + return new SourceChange(message, edits, linkedEditGroups, selection: selection);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "SourceChange");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["message"] = message;
|
| + result["edits"] = edits.map((SourceFileEdit value) => value.toJson());
|
| + result["linkedEditGroups"] = linkedEditGroups.map((LinkedEditGroup value) => value.toJson());
|
| + if (selection != null) {
|
| + result["selection"] = selection.toJson();
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SourceChange) {
|
| + return message == other.message &&
|
| + _listEqual(edits, other.edits, (SourceFileEdit a, SourceFileEdit b) => a == b) &&
|
| + _listEqual(linkedEditGroups, other.linkedEditGroups, (LinkedEditGroup a, LinkedEditGroup b) => a == b) &&
|
| + selection == other.selection;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, message.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, linkedEditGroups.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, selection.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * SourceEdit
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * "replacement": String
|
| + * "id": optional String
|
| + * }
|
| + */
|
| +class SourceEdit {
|
| + /**
|
| + * The offset of the region to be modified.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the region to be modified.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The code that is to replace the specified region in the original code.
|
| + */
|
| + final String replacement;
|
| +
|
| + /**
|
| + * An identifier that uniquely identifies this source edit from other edits
|
| + * in the same response. This field is omitted unless a containing structure
|
| + * needs to be able to identify the edit for some reason.
|
| + *
|
| + * For example, some refactoring operations can produce edits that might not
|
| + * be appropriate (referred to as potential edits). Such edits will have an
|
| + * id so that they can be referenced. Edits in the same response that do not
|
| + * need to be referenced will not have an id.
|
| + */
|
| + final String id;
|
| +
|
| + SourceEdit(this.offset, this.length, this.replacement, {this.id});
|
| +
|
| + factory SourceEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + String replacement;
|
| + if (json.containsKey("replacement")) {
|
| + replacement = jsonDecoder._decodeString(jsonPath + ".replacement", json["replacement"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "replacement");
|
| + }
|
| + String id;
|
| + if (json.containsKey("id")) {
|
| + id = jsonDecoder._decodeString(jsonPath + ".id", json["id"]);
|
| + }
|
| + return new SourceEdit(offset, length, replacement, id: id);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "SourceEdit");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + result["replacement"] = replacement;
|
| + if (id != null) {
|
| + result["id"] = id;
|
| + }
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SourceEdit) {
|
| + return offset == other.offset &&
|
| + length == other.length &&
|
| + replacement == other.replacement &&
|
| + id == other.id;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, replacement.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, id.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * SourceFileEdit
|
| + *
|
| + * {
|
| + * "file": FilePath
|
| + * "edits": List<SourceEdit>
|
| + * }
|
| + */
|
| +class SourceFileEdit {
|
| + /**
|
| + * The file containing the code to be modified.
|
| + */
|
| + final String file;
|
| +
|
| + /**
|
| + * A list of the edits used to effect the change.
|
| + */
|
| + final List<SourceEdit> edits;
|
| +
|
| + SourceFileEdit(this.file, this.edits);
|
| +
|
| + factory SourceFileEdit.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String file;
|
| + if (json.containsKey("file")) {
|
| + file = jsonDecoder._decodeString(jsonPath + ".file", json["file"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "file");
|
| + }
|
| + List<SourceEdit> edits;
|
| + if (json.containsKey("edits")) {
|
| + edits = jsonDecoder._decodeList(jsonPath + ".edits", json["edits"], (String jsonPath, Object json) => new SourceEdit.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "edits");
|
| + }
|
| + return new SourceFileEdit(file, edits);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "SourceFileEdit");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["file"] = file;
|
| + result["edits"] = edits.map((SourceEdit value) => value.toJson());
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is SourceFileEdit) {
|
| + return file == other.file &&
|
| + _listEqual(edits, other.edits, (SourceEdit a, SourceEdit b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, file.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, edits.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * TypeHierarchyItem
|
| + *
|
| + * {
|
| + * "classElement": Element
|
| + * "displayName": optional String
|
| + * "memberElement": optional Element
|
| + * "superclass": optional int
|
| + * "interfaces": List<int>
|
| + * "mixins": List<int>
|
| + * "subclasses": List<int>
|
| + * }
|
| + */
|
| +class TypeHierarchyItem {
|
| + /**
|
| + * The class element represented by this item.
|
| + */
|
| + final Element classElement;
|
| +
|
| + /**
|
| + * The name to be displayed for the class. This field will be omitted if the
|
| + * display name is the same as the name of the element. The display name is
|
| + * different if there is additional type information to be displayed, such as
|
| + * type arguments.
|
| + */
|
| + final String displayName;
|
| +
|
| + /**
|
| + * The member in the class corresponding to the member on which the hierarchy
|
| + * was requested. This field will be omitted if the hierarchy was not
|
| + * requested for a member or if the class does not have a corresponding
|
| + * member.
|
| + */
|
| + final Element memberElement;
|
| +
|
| + /**
|
| + * The index of the item representing the superclass of this class. This
|
| + * field will be omitted if this item represents the class Object.
|
| + */
|
| + final int superclass;
|
| +
|
| + /**
|
| + * The indexes of the items representing the interfaces implemented by this
|
| + * class. The list will be empty if there are no implemented interfaces.
|
| + */
|
| + final List<int> interfaces;
|
| +
|
| + /**
|
| + * The indexes of the items representing the mixins referenced by this class.
|
| + * The list will be empty if there are no classes mixed in to this class.
|
| + */
|
| + final List<int> mixins;
|
| +
|
| + /**
|
| + * The indexes of the items representing the subtypes of this class. The list
|
| + * will be empty if there are no subtypes or if this item represents a
|
| + * supertype of the pivot type.
|
| + */
|
| + final List<int> subclasses;
|
| +
|
| + TypeHierarchyItem(this.classElement, this.interfaces, this.mixins, this.subclasses, {this.displayName, this.memberElement, this.superclass});
|
| +
|
| + factory TypeHierarchyItem.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + Element classElement;
|
| + if (json.containsKey("classElement")) {
|
| + classElement = new Element.fromJson(jsonDecoder, jsonPath + ".classElement", json["classElement"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "classElement");
|
| + }
|
| + String displayName;
|
| + if (json.containsKey("displayName")) {
|
| + displayName = jsonDecoder._decodeString(jsonPath + ".displayName", json["displayName"]);
|
| + }
|
| + Element memberElement;
|
| + if (json.containsKey("memberElement")) {
|
| + memberElement = new Element.fromJson(jsonDecoder, jsonPath + ".memberElement", json["memberElement"]);
|
| + }
|
| + int superclass;
|
| + if (json.containsKey("superclass")) {
|
| + superclass = jsonDecoder._decodeInt(jsonPath + ".superclass", json["superclass"]);
|
| + }
|
| + List<int> interfaces;
|
| + if (json.containsKey("interfaces")) {
|
| + interfaces = jsonDecoder._decodeList(jsonPath + ".interfaces", json["interfaces"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "interfaces");
|
| + }
|
| + List<int> mixins;
|
| + if (json.containsKey("mixins")) {
|
| + mixins = jsonDecoder._decodeList(jsonPath + ".mixins", json["mixins"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "mixins");
|
| + }
|
| + List<int> subclasses;
|
| + if (json.containsKey("subclasses")) {
|
| + subclasses = jsonDecoder._decodeList(jsonPath + ".subclasses", json["subclasses"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "subclasses");
|
| + }
|
| + return new TypeHierarchyItem(classElement, interfaces, mixins, subclasses, displayName: displayName, memberElement: memberElement, superclass: superclass);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "TypeHierarchyItem");
|
| + }
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["classElement"] = classElement.toJson();
|
| + if (displayName != null) {
|
| + result["displayName"] = displayName;
|
| + }
|
| + if (memberElement != null) {
|
| + result["memberElement"] = memberElement.toJson();
|
| + }
|
| + if (superclass != null) {
|
| + result["superclass"] = superclass;
|
| + }
|
| + result["interfaces"] = interfaces;
|
| + result["mixins"] = mixins;
|
| + result["subclasses"] = subclasses;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is TypeHierarchyItem) {
|
| + return classElement == other.classElement &&
|
| + displayName == other.displayName &&
|
| + memberElement == other.memberElement &&
|
| + superclass == other.superclass &&
|
| + _listEqual(interfaces, other.interfaces, (int a, int b) => a == b) &&
|
| + _listEqual(mixins, other.mixins, (int a, int b) => a == b) &&
|
| + _listEqual(subclasses, other.subclasses, (int a, int b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, classElement.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, displayName.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, memberElement.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, superclass.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, interfaces.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, mixins.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, subclasses.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * extractLocalVariable feedback
|
| + *
|
| + * {
|
| + * "names": List<String>
|
| + * "offsets": List<int>
|
| + * "lengths": List<int>
|
| + * }
|
| + */
|
| +class ExtractLocalVariableFeedback {
|
| + /**
|
| + * The proposed names for the local variable.
|
| + */
|
| + final List<String> names;
|
| +
|
| + /**
|
| + * The offsets of the expressions that would be replaced by a reference to
|
| + * the variable.
|
| + */
|
| + final List<int> offsets;
|
| +
|
| + /**
|
| + * The lengths of the expressions that would be replaced by a reference to
|
| + * the variable. The lengths correspond to the offsets. In other words, for a
|
| + * given expression, if the offset of that expression is offsets[i], then the
|
| + * length of that expression is lengths[i].
|
| + */
|
| + final List<int> lengths;
|
| +
|
| + ExtractLocalVariableFeedback(this.names, this.offsets, this.lengths);
|
| +
|
| + factory ExtractLocalVariableFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + List<String> names;
|
| + if (json.containsKey("names")) {
|
| + names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "names");
|
| + }
|
| + List<int> offsets;
|
| + if (json.containsKey("offsets")) {
|
| + offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offsets");
|
| + }
|
| + List<int> lengths;
|
| + if (json.containsKey("lengths")) {
|
| + lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "lengths");
|
| + }
|
| + return new ExtractLocalVariableFeedback(names, offsets, lengths);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable feedback");
|
| + }
|
| + }
|
| +
|
| + factory ExtractLocalVariableFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
|
| + return new ExtractLocalVariableFeedback.fromJson(
|
| + new ResponseDecoder(), "feedback", refactoringResult.feedback);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["names"] = names;
|
| + result["offsets"] = offsets;
|
| + result["lengths"] = lengths;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ExtractLocalVariableFeedback) {
|
| + return _listEqual(names, other.names, (String a, String b) => a == b) &&
|
| + _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
|
| + _listEqual(lengths, other.lengths, (int a, int b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, names.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, lengths.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * extractLocalVariable options
|
| + *
|
| + * {
|
| + * "name": String
|
| + * "extractAll": bool
|
| + * }
|
| + */
|
| +class ExtractLocalVariableOptions {
|
| + /**
|
| + * The name that the local variable should be given.
|
| + */
|
| + final String name;
|
| +
|
| + /**
|
| + * True if all occurrences of the expression within the scope in which the
|
| + * variable will be defined should be replaced by a reference to the local
|
| + * variable. The expression used to initiate the refactoring will always be
|
| + * replaced.
|
| + */
|
| + final bool extractAll;
|
| +
|
| + ExtractLocalVariableOptions(this.name, this.extractAll);
|
| +
|
| + factory ExtractLocalVariableOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + bool extractAll;
|
| + if (json.containsKey("extractAll")) {
|
| + extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "extractAll");
|
| + }
|
| + return new ExtractLocalVariableOptions(name, extractAll);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "extractLocalVariable options");
|
| + }
|
| + }
|
| +
|
| + factory ExtractLocalVariableOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
|
| + return new ExtractLocalVariableOptions.fromJson(
|
| + new RequestDecoder(request), "options", refactoringParams.options);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["name"] = name;
|
| + result["extractAll"] = extractAll;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ExtractLocalVariableOptions) {
|
| + return name == other.name &&
|
| + extractAll == other.extractAll;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * extractMethod feedback
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * "returnType": String
|
| + * "names": List<String>
|
| + * "canCreateGetter": bool
|
| + * "parameters": List<RefactoringMethodParameter>
|
| + * "occurrences": int
|
| + * "offsets": List<int>
|
| + * "lengths": List<int>
|
| + * }
|
| + */
|
| +class ExtractMethodFeedback {
|
| + /**
|
| + * The offset to the beginning of the expression or statements that will be
|
| + * extracted.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the expression or statements that will be extracted.
|
| + */
|
| + final int length;
|
| +
|
| + /**
|
| + * The proposed return type for the method.
|
| + */
|
| + final String returnType;
|
| +
|
| + /**
|
| + * The proposed names for the method.
|
| + */
|
| + final List<String> names;
|
| +
|
| + /**
|
| + * True if a getter could be created rather than a method.
|
| + */
|
| + final bool canCreateGetter;
|
| +
|
| + /**
|
| + * The proposed parameters for the method.
|
| + */
|
| + final List<RefactoringMethodParameter> parameters;
|
| +
|
| + /**
|
| + * The number of times the expression or statements occurs.
|
| + */
|
| + final int occurrences;
|
| +
|
| + /**
|
| + * The offsets of the expressions or statements that would be replaced by an
|
| + * invocation of the method.
|
| + */
|
| + final List<int> offsets;
|
| +
|
| + /**
|
| + * The lengths of the expressions or statements that would be replaced by an
|
| + * invocation of the method. The lengths correspond to the offsets. In other
|
| + * words, for a given expression (or block of statements), if the offset of
|
| + * that expression is offsets[i], then the length of that expression is
|
| + * lengths[i].
|
| + */
|
| + final List<int> lengths;
|
| +
|
| + ExtractMethodFeedback(this.offset, this.length, this.returnType, this.names, this.canCreateGetter, this.parameters, this.occurrences, this.offsets, this.lengths);
|
| +
|
| + factory ExtractMethodFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + String returnType;
|
| + if (json.containsKey("returnType")) {
|
| + returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "returnType");
|
| + }
|
| + List<String> names;
|
| + if (json.containsKey("names")) {
|
| + names = jsonDecoder._decodeList(jsonPath + ".names", json["names"], jsonDecoder._decodeString);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "names");
|
| + }
|
| + bool canCreateGetter;
|
| + if (json.containsKey("canCreateGetter")) {
|
| + canCreateGetter = jsonDecoder._decodeBool(jsonPath + ".canCreateGetter", json["canCreateGetter"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "canCreateGetter");
|
| + }
|
| + List<RefactoringMethodParameter> parameters;
|
| + if (json.containsKey("parameters")) {
|
| + parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "parameters");
|
| + }
|
| + int occurrences;
|
| + if (json.containsKey("occurrences")) {
|
| + occurrences = jsonDecoder._decodeInt(jsonPath + ".occurrences", json["occurrences"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "occurrences");
|
| + }
|
| + List<int> offsets;
|
| + if (json.containsKey("offsets")) {
|
| + offsets = jsonDecoder._decodeList(jsonPath + ".offsets", json["offsets"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offsets");
|
| + }
|
| + List<int> lengths;
|
| + if (json.containsKey("lengths")) {
|
| + lengths = jsonDecoder._decodeList(jsonPath + ".lengths", json["lengths"], jsonDecoder._decodeInt);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "lengths");
|
| + }
|
| + return new ExtractMethodFeedback(offset, length, returnType, names, canCreateGetter, parameters, occurrences, offsets, lengths);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "extractMethod feedback");
|
| + }
|
| + }
|
| +
|
| + factory ExtractMethodFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
|
| + return new ExtractMethodFeedback.fromJson(
|
| + new ResponseDecoder(), "feedback", refactoringResult.feedback);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + result["returnType"] = returnType;
|
| + result["names"] = names;
|
| + result["canCreateGetter"] = canCreateGetter;
|
| + result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson());
|
| + result["occurrences"] = occurrences;
|
| + result["offsets"] = offsets;
|
| + result["lengths"] = lengths;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ExtractMethodFeedback) {
|
| + return offset == other.offset &&
|
| + length == other.length &&
|
| + returnType == other.returnType &&
|
| + _listEqual(names, other.names, (String a, String b) => a == b) &&
|
| + canCreateGetter == other.canCreateGetter &&
|
| + _listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
|
| + occurrences == other.occurrences &&
|
| + _listEqual(offsets, other.offsets, (int a, int b) => a == b) &&
|
| + _listEqual(lengths, other.lengths, (int a, int b) => a == b);
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, names.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, canCreateGetter.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, occurrences.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, offsets.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, lengths.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * extractMethod options
|
| + *
|
| + * {
|
| + * "returnType": String
|
| + * "createGetter": bool
|
| + * "name": String
|
| + * "parameters": List<RefactoringMethodParameter>
|
| + * "extractAll": bool
|
| + * }
|
| + */
|
| +class ExtractMethodOptions {
|
| + /**
|
| + * The return type that should be defined for the method.
|
| + */
|
| + final String returnType;
|
| +
|
| + /**
|
| + * True if a getter should be created rather than a method. It is an error if
|
| + * this field is true and the list of parameters is non-empty.
|
| + */
|
| + final bool createGetter;
|
| +
|
| + /**
|
| + * The name that the method should be given.
|
| + */
|
| + final String name;
|
| +
|
| + /**
|
| + * The parameters that should be defined for the method.
|
| + *
|
| + * It is an error if a REQUIRED or NAMED parameter follows a POSITIONAL
|
| + * parameter. It is an error if a REQUIRED or POSITIONAL parameter follows a
|
| + * NAMED parameter.
|
| + *
|
| + * - To change the order and/or update proposed paramerers, add parameters
|
| + * with the same identifiers as proposed.
|
| + * - To add new parameters, omit their identifier.
|
| + * - To remove some parameters, omit them in this list.
|
| + */
|
| + final List<RefactoringMethodParameter> parameters;
|
| +
|
| + /**
|
| + * True if all occurrences of the expression or statements should be replaced
|
| + * by an invocation of the method. The expression or statements used to
|
| + * initiate the refactoring will always be replaced.
|
| + */
|
| + final bool extractAll;
|
| +
|
| + ExtractMethodOptions(this.returnType, this.createGetter, this.name, this.parameters, this.extractAll);
|
| +
|
| + factory ExtractMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String returnType;
|
| + if (json.containsKey("returnType")) {
|
| + returnType = jsonDecoder._decodeString(jsonPath + ".returnType", json["returnType"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "returnType");
|
| + }
|
| + bool createGetter;
|
| + if (json.containsKey("createGetter")) {
|
| + createGetter = jsonDecoder._decodeBool(jsonPath + ".createGetter", json["createGetter"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "createGetter");
|
| + }
|
| + String name;
|
| + if (json.containsKey("name")) {
|
| + name = jsonDecoder._decodeString(jsonPath + ".name", json["name"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "name");
|
| + }
|
| + List<RefactoringMethodParameter> parameters;
|
| + if (json.containsKey("parameters")) {
|
| + parameters = jsonDecoder._decodeList(jsonPath + ".parameters", json["parameters"], (String jsonPath, Object json) => new RefactoringMethodParameter.fromJson(jsonDecoder, jsonPath, json));
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "parameters");
|
| + }
|
| + bool extractAll;
|
| + if (json.containsKey("extractAll")) {
|
| + extractAll = jsonDecoder._decodeBool(jsonPath + ".extractAll", json["extractAll"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "extractAll");
|
| + }
|
| + return new ExtractMethodOptions(returnType, createGetter, name, parameters, extractAll);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "extractMethod options");
|
| + }
|
| + }
|
| +
|
| + factory ExtractMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
|
| + return new ExtractMethodOptions.fromJson(
|
| + new RequestDecoder(request), "options", refactoringParams.options);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["returnType"] = returnType;
|
| + result["createGetter"] = createGetter;
|
| + result["name"] = name;
|
| + result["parameters"] = parameters.map((RefactoringMethodParameter value) => value.toJson());
|
| + result["extractAll"] = extractAll;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is ExtractMethodOptions) {
|
| + return returnType == other.returnType &&
|
| + createGetter == other.createGetter &&
|
| + name == other.name &&
|
| + _listEqual(parameters, other.parameters, (RefactoringMethodParameter a, RefactoringMethodParameter b) => a == b) &&
|
| + extractAll == other.extractAll;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, returnType.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, createGetter.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, name.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, parameters.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, extractAll.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * inlineMethod options
|
| + *
|
| + * {
|
| + * "deleteSource": bool
|
| + * "inlineAll": bool
|
| + * }
|
| + */
|
| +class InlineMethodOptions {
|
| + /**
|
| + * True if the method being inlined should be removed. It is an error if this
|
| + * field is true and inlineAll is false.
|
| + */
|
| + final bool deleteSource;
|
| +
|
| + /**
|
| + * True if all invocations of the method should be inlined, or false if only
|
| + * the invocation site used to create this refactoring should be inlined.
|
| + */
|
| + final bool inlineAll;
|
| +
|
| + InlineMethodOptions(this.deleteSource, this.inlineAll);
|
| +
|
| + factory InlineMethodOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + bool deleteSource;
|
| + if (json.containsKey("deleteSource")) {
|
| + deleteSource = jsonDecoder._decodeBool(jsonPath + ".deleteSource", json["deleteSource"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "deleteSource");
|
| + }
|
| + bool inlineAll;
|
| + if (json.containsKey("inlineAll")) {
|
| + inlineAll = jsonDecoder._decodeBool(jsonPath + ".inlineAll", json["inlineAll"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "inlineAll");
|
| + }
|
| + return new InlineMethodOptions(deleteSource, inlineAll);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "inlineMethod options");
|
| + }
|
| + }
|
| +
|
| + factory InlineMethodOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
|
| + return new InlineMethodOptions.fromJson(
|
| + new RequestDecoder(request), "options", refactoringParams.options);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["deleteSource"] = deleteSource;
|
| + result["inlineAll"] = inlineAll;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is InlineMethodOptions) {
|
| + return deleteSource == other.deleteSource &&
|
| + inlineAll == other.inlineAll;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, deleteSource.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, inlineAll.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * rename feedback
|
| + *
|
| + * {
|
| + * "offset": int
|
| + * "length": int
|
| + * }
|
| + */
|
| +class RenameFeedback {
|
| + /**
|
| + * The offset to the beginning of the name selected to be renamed.
|
| + */
|
| + final int offset;
|
| +
|
| + /**
|
| + * The length of the name selected to be renamed.
|
| + */
|
| + final int length;
|
| +
|
| + RenameFeedback(this.offset, this.length);
|
| +
|
| + factory RenameFeedback.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + int offset;
|
| + if (json.containsKey("offset")) {
|
| + offset = jsonDecoder._decodeInt(jsonPath + ".offset", json["offset"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "offset");
|
| + }
|
| + int length;
|
| + if (json.containsKey("length")) {
|
| + length = jsonDecoder._decodeInt(jsonPath + ".length", json["length"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "length");
|
| + }
|
| + return new RenameFeedback(offset, length);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "rename feedback");
|
| + }
|
| + }
|
| +
|
| + factory RenameFeedback.fromRefactoringResult(EditGetRefactoringResult refactoringResult) {
|
| + return new RenameFeedback.fromJson(
|
| + new ResponseDecoder(), "feedback", refactoringResult.feedback);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["offset"] = offset;
|
| + result["length"] = length;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is RenameFeedback) {
|
| + return offset == other.offset &&
|
| + length == other.length;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, offset.hashCode);
|
| + hash = _JenkinsSmiHash.combine(hash, length.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * rename options
|
| + *
|
| + * {
|
| + * "newName": String
|
| + * }
|
| + */
|
| +class RenameOptions {
|
| + /**
|
| + * The name that the element should have after the refactoring.
|
| + */
|
| + final String newName;
|
| +
|
| + RenameOptions(this.newName);
|
| +
|
| + factory RenameOptions.fromJson(JsonDecoder jsonDecoder, String jsonPath, Object json) {
|
| + if (json is Map) {
|
| + String newName;
|
| + if (json.containsKey("newName")) {
|
| + newName = jsonDecoder._decodeString(jsonPath + ".newName", json["newName"]);
|
| + } else {
|
| + throw jsonDecoder.missingKey(jsonPath, "newName");
|
| + }
|
| + return new RenameOptions(newName);
|
| + } else {
|
| + throw jsonDecoder.mismatch(jsonPath, "rename options");
|
| + }
|
| + }
|
| +
|
| + factory RenameOptions.fromRefactoringParams(EditGetRefactoringParams refactoringParams, Request request) {
|
| + return new RenameOptions.fromJson(
|
| + new RequestDecoder(request), "options", refactoringParams.options);
|
| + }
|
| +
|
| + Map<String, dynamic> toJson() {
|
| + Map<String, dynamic> result = {};
|
| + result["newName"] = newName;
|
| + return result;
|
| + }
|
| +
|
| + @override
|
| + String toString() => JSON.encode(toJson());
|
| +
|
| + @override
|
| + bool operator==(other) {
|
| + if (other is RenameOptions) {
|
| + return newName == other.newName;
|
| + }
|
| + return false;
|
| + }
|
| +
|
| + @override
|
| + int get hashCode {
|
| + int hash = 0;
|
| + hash = _JenkinsSmiHash.combine(hash, newName.hashCode);
|
| + return _JenkinsSmiHash.finish(hash);
|
| + }
|
| +}
|
|
|
Chromium Code Reviews
Issue 479043002:
Code generate Dart classes representing the analysis server API. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart