Konstantin Shcheglov
c8d6f85d0f
Change-Id: Ib68c124988743b45807015e7274f429fff67fe44 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/189384 Reviewed-by: Brian Wilkerson <brianwilkerson@google.com> Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
1576 lines
46 KiB
Dart
1576 lines
46 KiB
Dart
// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
// This file has been automatically generated. Please do not edit it manually.
|
|
// To regenerate the file, use the script
|
|
// "pkg/analysis_server/tool/lsp_spec/generate_all.dart".
|
|
|
|
// ignore_for_file: annotate_overrides
|
|
// ignore_for_file: deprecated_member_use
|
|
// ignore_for_file: deprecated_member_use_from_same_package
|
|
// ignore_for_file: unnecessary_brace_in_string_interps
|
|
// ignore_for_file: unnecessary_parenthesis
|
|
// ignore_for_file: unused_import
|
|
// ignore_for_file: unused_shown_name
|
|
|
|
import 'dart:core' hide deprecated;
|
|
import 'dart:core' as core show deprecated;
|
|
import 'dart:convert' show JsonEncoder;
|
|
import 'package:analysis_server/lsp_protocol/protocol_generated.dart';
|
|
import 'package:analysis_server/lsp_protocol/protocol_special.dart';
|
|
import 'package:analysis_server/src/lsp/json_parsing.dart';
|
|
import 'package:analysis_server/src/protocol/protocol_internal.dart'
|
|
show listEqual, mapEqual;
|
|
import 'package:analyzer/src/generated/utilities_general.dart';
|
|
import 'package:meta/meta.dart';
|
|
|
|
const jsonEncoder = JsonEncoder.withIndent(' ');
|
|
|
|
class AnalyzerStatusParams implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
AnalyzerStatusParams.canParse, AnalyzerStatusParams.fromJson);
|
|
|
|
AnalyzerStatusParams({@required this.isAnalyzing}) {
|
|
if (isAnalyzing == null) {
|
|
throw 'isAnalyzing is required but was not provided';
|
|
}
|
|
}
|
|
static AnalyzerStatusParams fromJson(Map<String, dynamic> json) {
|
|
final isAnalyzing = json['isAnalyzing'];
|
|
return AnalyzerStatusParams(isAnalyzing: isAnalyzing);
|
|
}
|
|
|
|
final bool isAnalyzing;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['isAnalyzing'] =
|
|
isAnalyzing ?? (throw 'isAnalyzing is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('isAnalyzing');
|
|
try {
|
|
if (!obj.containsKey('isAnalyzing')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['isAnalyzing'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['isAnalyzing'] is bool)) {
|
|
reporter.reportError('must be of type bool');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type AnalyzerStatusParams');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is AnalyzerStatusParams &&
|
|
other.runtimeType == AnalyzerStatusParams) {
|
|
return isAnalyzing == other.isAnalyzing && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, isAnalyzing.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class ClosingLabel implements ToJsonable {
|
|
static const jsonHandler =
|
|
LspJsonHandler(ClosingLabel.canParse, ClosingLabel.fromJson);
|
|
|
|
ClosingLabel({@required this.range, @required this.label}) {
|
|
if (range == null) {
|
|
throw 'range is required but was not provided';
|
|
}
|
|
if (label == null) {
|
|
throw 'label is required but was not provided';
|
|
}
|
|
}
|
|
static ClosingLabel fromJson(Map<String, dynamic> json) {
|
|
final range = json['range'] != null ? Range.fromJson(json['range']) : null;
|
|
final label = json['label'];
|
|
return ClosingLabel(range: range, label: label);
|
|
}
|
|
|
|
final String label;
|
|
final Range range;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['range'] =
|
|
range?.toJson() ?? (throw 'range is required but was not set');
|
|
__result['label'] = label ?? (throw 'label is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('range');
|
|
try {
|
|
if (!obj.containsKey('range')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['range'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Range.canParse(obj['range'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('label');
|
|
try {
|
|
if (!obj.containsKey('label')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['label'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['label'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type ClosingLabel');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is ClosingLabel && other.runtimeType == ClosingLabel) {
|
|
return range == other.range && label == other.label && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, range.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, label.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class CompletionItemResolutionInfo implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
CompletionItemResolutionInfo.canParse,
|
|
CompletionItemResolutionInfo.fromJson);
|
|
|
|
CompletionItemResolutionInfo({@required this.file, @required this.offset}) {
|
|
if (file == null) {
|
|
throw 'file is required but was not provided';
|
|
}
|
|
if (offset == null) {
|
|
throw 'offset is required but was not provided';
|
|
}
|
|
}
|
|
static CompletionItemResolutionInfo fromJson(Map<String, dynamic> json) {
|
|
if (DartCompletionItemResolutionInfo.canParse(json, nullLspJsonReporter)) {
|
|
return DartCompletionItemResolutionInfo.fromJson(json);
|
|
}
|
|
final file = json['file'];
|
|
final offset = json['offset'];
|
|
return CompletionItemResolutionInfo(file: file, offset: offset);
|
|
}
|
|
|
|
final String file;
|
|
final num offset;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['file'] = file ?? (throw 'file is required but was not set');
|
|
__result['offset'] = offset ?? (throw 'offset is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('file');
|
|
try {
|
|
if (!obj.containsKey('file')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['file'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['file'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('offset');
|
|
try {
|
|
if (!obj.containsKey('offset')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['offset'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['offset'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type CompletionItemResolutionInfo');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is CompletionItemResolutionInfo &&
|
|
other.runtimeType == CompletionItemResolutionInfo) {
|
|
return file == other.file && offset == other.offset && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, file.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, offset.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class DartCompletionItemResolutionInfo
|
|
implements CompletionItemResolutionInfo, ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
DartCompletionItemResolutionInfo.canParse,
|
|
DartCompletionItemResolutionInfo.fromJson);
|
|
|
|
DartCompletionItemResolutionInfo(
|
|
{@required this.libId,
|
|
@required this.displayUri,
|
|
@required this.rOffset,
|
|
@required this.iLength,
|
|
@required this.rLength,
|
|
@required this.file,
|
|
@required this.offset}) {
|
|
if (libId == null) {
|
|
throw 'libId is required but was not provided';
|
|
}
|
|
if (displayUri == null) {
|
|
throw 'displayUri is required but was not provided';
|
|
}
|
|
if (rOffset == null) {
|
|
throw 'rOffset is required but was not provided';
|
|
}
|
|
if (iLength == null) {
|
|
throw 'iLength is required but was not provided';
|
|
}
|
|
if (rLength == null) {
|
|
throw 'rLength is required but was not provided';
|
|
}
|
|
if (file == null) {
|
|
throw 'file is required but was not provided';
|
|
}
|
|
if (offset == null) {
|
|
throw 'offset is required but was not provided';
|
|
}
|
|
}
|
|
static DartCompletionItemResolutionInfo fromJson(Map<String, dynamic> json) {
|
|
final libId = json['libId'];
|
|
final displayUri = json['displayUri'];
|
|
final rOffset = json['rOffset'];
|
|
final iLength = json['iLength'];
|
|
final rLength = json['rLength'];
|
|
final file = json['file'];
|
|
final offset = json['offset'];
|
|
return DartCompletionItemResolutionInfo(
|
|
libId: libId,
|
|
displayUri: displayUri,
|
|
rOffset: rOffset,
|
|
iLength: iLength,
|
|
rLength: rLength,
|
|
file: file,
|
|
offset: offset);
|
|
}
|
|
|
|
final String displayUri;
|
|
final String file;
|
|
final num iLength;
|
|
final num libId;
|
|
final num offset;
|
|
final num rLength;
|
|
final num rOffset;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['libId'] = libId ?? (throw 'libId is required but was not set');
|
|
__result['displayUri'] =
|
|
displayUri ?? (throw 'displayUri is required but was not set');
|
|
__result['rOffset'] =
|
|
rOffset ?? (throw 'rOffset is required but was not set');
|
|
__result['iLength'] =
|
|
iLength ?? (throw 'iLength is required but was not set');
|
|
__result['rLength'] =
|
|
rLength ?? (throw 'rLength is required but was not set');
|
|
__result['file'] = file ?? (throw 'file is required but was not set');
|
|
__result['offset'] = offset ?? (throw 'offset is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('libId');
|
|
try {
|
|
if (!obj.containsKey('libId')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['libId'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['libId'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('displayUri');
|
|
try {
|
|
if (!obj.containsKey('displayUri')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['displayUri'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['displayUri'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('rOffset');
|
|
try {
|
|
if (!obj.containsKey('rOffset')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['rOffset'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['rOffset'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('iLength');
|
|
try {
|
|
if (!obj.containsKey('iLength')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['iLength'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['iLength'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('rLength');
|
|
try {
|
|
if (!obj.containsKey('rLength')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['rLength'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['rLength'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('file');
|
|
try {
|
|
if (!obj.containsKey('file')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['file'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['file'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('offset');
|
|
try {
|
|
if (!obj.containsKey('offset')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['offset'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['offset'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type DartCompletionItemResolutionInfo');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is DartCompletionItemResolutionInfo &&
|
|
other.runtimeType == DartCompletionItemResolutionInfo) {
|
|
return libId == other.libId &&
|
|
displayUri == other.displayUri &&
|
|
rOffset == other.rOffset &&
|
|
iLength == other.iLength &&
|
|
rLength == other.rLength &&
|
|
file == other.file &&
|
|
offset == other.offset &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, libId.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, displayUri.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, rOffset.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, iLength.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, rLength.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, file.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, offset.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class DartDiagnosticServer implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
DartDiagnosticServer.canParse, DartDiagnosticServer.fromJson);
|
|
|
|
DartDiagnosticServer({@required this.port}) {
|
|
if (port == null) {
|
|
throw 'port is required but was not provided';
|
|
}
|
|
}
|
|
static DartDiagnosticServer fromJson(Map<String, dynamic> json) {
|
|
final port = json['port'];
|
|
return DartDiagnosticServer(port: port);
|
|
}
|
|
|
|
final num port;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['port'] = port ?? (throw 'port is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('port');
|
|
try {
|
|
if (!obj.containsKey('port')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['port'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['port'] is num)) {
|
|
reporter.reportError('must be of type num');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type DartDiagnosticServer');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is DartDiagnosticServer &&
|
|
other.runtimeType == DartDiagnosticServer) {
|
|
return port == other.port && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, port.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class Element implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(Element.canParse, Element.fromJson);
|
|
|
|
Element(
|
|
{this.range,
|
|
@required this.name,
|
|
@required this.kind,
|
|
this.parameters,
|
|
this.typeParameters,
|
|
this.returnType}) {
|
|
if (name == null) {
|
|
throw 'name is required but was not provided';
|
|
}
|
|
if (kind == null) {
|
|
throw 'kind is required but was not provided';
|
|
}
|
|
}
|
|
static Element fromJson(Map<String, dynamic> json) {
|
|
final range = json['range'] != null ? Range.fromJson(json['range']) : null;
|
|
final name = json['name'];
|
|
final kind = json['kind'];
|
|
final parameters = json['parameters'];
|
|
final typeParameters = json['typeParameters'];
|
|
final returnType = json['returnType'];
|
|
return Element(
|
|
range: range,
|
|
name: name,
|
|
kind: kind,
|
|
parameters: parameters,
|
|
typeParameters: typeParameters,
|
|
returnType: returnType);
|
|
}
|
|
|
|
final String kind;
|
|
final String name;
|
|
final String parameters;
|
|
final Range range;
|
|
final String returnType;
|
|
final String typeParameters;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
if (range != null) {
|
|
__result['range'] = range.toJson();
|
|
}
|
|
__result['name'] = name ?? (throw 'name is required but was not set');
|
|
__result['kind'] = kind ?? (throw 'kind is required but was not set');
|
|
if (parameters != null) {
|
|
__result['parameters'] = parameters;
|
|
}
|
|
if (typeParameters != null) {
|
|
__result['typeParameters'] = typeParameters;
|
|
}
|
|
if (returnType != null) {
|
|
__result['returnType'] = returnType;
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('range');
|
|
try {
|
|
if (obj['range'] != null && !(Range.canParse(obj['range'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('name');
|
|
try {
|
|
if (!obj.containsKey('name')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['name'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['name'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('kind');
|
|
try {
|
|
if (!obj.containsKey('kind')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['kind'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['kind'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('parameters');
|
|
try {
|
|
if (obj['parameters'] != null && !(obj['parameters'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('typeParameters');
|
|
try {
|
|
if (obj['typeParameters'] != null &&
|
|
!(obj['typeParameters'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('returnType');
|
|
try {
|
|
if (obj['returnType'] != null && !(obj['returnType'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type Element');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is Element && other.runtimeType == Element) {
|
|
return range == other.range &&
|
|
name == other.name &&
|
|
kind == other.kind &&
|
|
parameters == other.parameters &&
|
|
typeParameters == other.typeParameters &&
|
|
returnType == other.returnType &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, range.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, name.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, kind.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, parameters.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, typeParameters.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, returnType.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class FlutterOutline implements ToJsonable {
|
|
static const jsonHandler =
|
|
LspJsonHandler(FlutterOutline.canParse, FlutterOutline.fromJson);
|
|
|
|
FlutterOutline(
|
|
{@required this.kind,
|
|
this.label,
|
|
this.className,
|
|
this.variableName,
|
|
this.attributes,
|
|
this.dartElement,
|
|
@required this.range,
|
|
@required this.codeRange,
|
|
this.children}) {
|
|
if (kind == null) {
|
|
throw 'kind is required but was not provided';
|
|
}
|
|
if (range == null) {
|
|
throw 'range is required but was not provided';
|
|
}
|
|
if (codeRange == null) {
|
|
throw 'codeRange is required but was not provided';
|
|
}
|
|
}
|
|
static FlutterOutline fromJson(Map<String, dynamic> json) {
|
|
final kind = json['kind'];
|
|
final label = json['label'];
|
|
final className = json['className'];
|
|
final variableName = json['variableName'];
|
|
final attributes = json['attributes']
|
|
?.map((item) =>
|
|
item != null ? FlutterOutlineAttribute.fromJson(item) : null)
|
|
?.cast<FlutterOutlineAttribute>()
|
|
?.toList();
|
|
final dartElement = json['dartElement'] != null
|
|
? Element.fromJson(json['dartElement'])
|
|
: null;
|
|
final range = json['range'] != null ? Range.fromJson(json['range']) : null;
|
|
final codeRange =
|
|
json['codeRange'] != null ? Range.fromJson(json['codeRange']) : null;
|
|
final children = json['children']
|
|
?.map((item) => item != null ? FlutterOutline.fromJson(item) : null)
|
|
?.cast<FlutterOutline>()
|
|
?.toList();
|
|
return FlutterOutline(
|
|
kind: kind,
|
|
label: label,
|
|
className: className,
|
|
variableName: variableName,
|
|
attributes: attributes,
|
|
dartElement: dartElement,
|
|
range: range,
|
|
codeRange: codeRange,
|
|
children: children);
|
|
}
|
|
|
|
final List<FlutterOutlineAttribute> attributes;
|
|
final List<FlutterOutline> children;
|
|
final String className;
|
|
final Range codeRange;
|
|
final Element dartElement;
|
|
final String kind;
|
|
final String label;
|
|
final Range range;
|
|
final String variableName;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['kind'] = kind ?? (throw 'kind is required but was not set');
|
|
if (label != null) {
|
|
__result['label'] = label;
|
|
}
|
|
if (className != null) {
|
|
__result['className'] = className;
|
|
}
|
|
if (variableName != null) {
|
|
__result['variableName'] = variableName;
|
|
}
|
|
if (attributes != null) {
|
|
__result['attributes'] = attributes.map((item) => item.toJson()).toList();
|
|
}
|
|
if (dartElement != null) {
|
|
__result['dartElement'] = dartElement.toJson();
|
|
}
|
|
__result['range'] =
|
|
range?.toJson() ?? (throw 'range is required but was not set');
|
|
__result['codeRange'] =
|
|
codeRange?.toJson() ?? (throw 'codeRange is required but was not set');
|
|
if (children != null) {
|
|
__result['children'] = children.map((item) => item.toJson()).toList();
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('kind');
|
|
try {
|
|
if (!obj.containsKey('kind')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['kind'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['kind'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('label');
|
|
try {
|
|
if (obj['label'] != null && !(obj['label'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('className');
|
|
try {
|
|
if (obj['className'] != null && !(obj['className'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('variableName');
|
|
try {
|
|
if (obj['variableName'] != null && !(obj['variableName'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('attributes');
|
|
try {
|
|
if (obj['attributes'] != null &&
|
|
!((obj['attributes'] is List &&
|
|
(obj['attributes'].every((item) =>
|
|
FlutterOutlineAttribute.canParse(item, reporter)))))) {
|
|
reporter.reportError('must be of type List<FlutterOutlineAttribute>');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('dartElement');
|
|
try {
|
|
if (obj['dartElement'] != null &&
|
|
!(Element.canParse(obj['dartElement'], reporter))) {
|
|
reporter.reportError('must be of type Element');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('range');
|
|
try {
|
|
if (!obj.containsKey('range')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['range'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Range.canParse(obj['range'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('codeRange');
|
|
try {
|
|
if (!obj.containsKey('codeRange')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['codeRange'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Range.canParse(obj['codeRange'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('children');
|
|
try {
|
|
if (obj['children'] != null &&
|
|
!((obj['children'] is List &&
|
|
(obj['children'].every(
|
|
(item) => FlutterOutline.canParse(item, reporter)))))) {
|
|
reporter.reportError('must be of type List<FlutterOutline>');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type FlutterOutline');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is FlutterOutline && other.runtimeType == FlutterOutline) {
|
|
return kind == other.kind &&
|
|
label == other.label &&
|
|
className == other.className &&
|
|
variableName == other.variableName &&
|
|
listEqual(
|
|
attributes,
|
|
other.attributes,
|
|
(FlutterOutlineAttribute a, FlutterOutlineAttribute b) =>
|
|
a == b) &&
|
|
dartElement == other.dartElement &&
|
|
range == other.range &&
|
|
codeRange == other.codeRange &&
|
|
listEqual(children, other.children,
|
|
(FlutterOutline a, FlutterOutline b) => a == b) &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, kind.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, label.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, className.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, variableName.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, lspHashCode(attributes));
|
|
hash = JenkinsSmiHash.combine(hash, dartElement.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, range.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, codeRange.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, lspHashCode(children));
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class FlutterOutlineAttribute implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
FlutterOutlineAttribute.canParse, FlutterOutlineAttribute.fromJson);
|
|
|
|
FlutterOutlineAttribute(
|
|
{@required this.name, @required this.label, this.valueRange}) {
|
|
if (name == null) {
|
|
throw 'name is required but was not provided';
|
|
}
|
|
if (label == null) {
|
|
throw 'label is required but was not provided';
|
|
}
|
|
}
|
|
static FlutterOutlineAttribute fromJson(Map<String, dynamic> json) {
|
|
final name = json['name'];
|
|
final label = json['label'];
|
|
final valueRange =
|
|
json['valueRange'] != null ? Range.fromJson(json['valueRange']) : null;
|
|
return FlutterOutlineAttribute(
|
|
name: name, label: label, valueRange: valueRange);
|
|
}
|
|
|
|
final String label;
|
|
final String name;
|
|
final Range valueRange;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['name'] = name ?? (throw 'name is required but was not set');
|
|
__result['label'] = label ?? (throw 'label is required but was not set');
|
|
if (valueRange != null) {
|
|
__result['valueRange'] = valueRange.toJson();
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('name');
|
|
try {
|
|
if (!obj.containsKey('name')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['name'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['name'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('label');
|
|
try {
|
|
if (!obj.containsKey('label')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['label'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['label'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('valueRange');
|
|
try {
|
|
if (obj['valueRange'] != null &&
|
|
!(Range.canParse(obj['valueRange'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type FlutterOutlineAttribute');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is FlutterOutlineAttribute &&
|
|
other.runtimeType == FlutterOutlineAttribute) {
|
|
return name == other.name &&
|
|
label == other.label &&
|
|
valueRange == other.valueRange &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, name.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, label.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, valueRange.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class Outline implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(Outline.canParse, Outline.fromJson);
|
|
|
|
Outline(
|
|
{@required this.element,
|
|
@required this.range,
|
|
@required this.codeRange,
|
|
this.children}) {
|
|
if (element == null) {
|
|
throw 'element is required but was not provided';
|
|
}
|
|
if (range == null) {
|
|
throw 'range is required but was not provided';
|
|
}
|
|
if (codeRange == null) {
|
|
throw 'codeRange is required but was not provided';
|
|
}
|
|
}
|
|
static Outline fromJson(Map<String, dynamic> json) {
|
|
final element =
|
|
json['element'] != null ? Element.fromJson(json['element']) : null;
|
|
final range = json['range'] != null ? Range.fromJson(json['range']) : null;
|
|
final codeRange =
|
|
json['codeRange'] != null ? Range.fromJson(json['codeRange']) : null;
|
|
final children = json['children']
|
|
?.map((item) => item != null ? Outline.fromJson(item) : null)
|
|
?.cast<Outline>()
|
|
?.toList();
|
|
return Outline(
|
|
element: element,
|
|
range: range,
|
|
codeRange: codeRange,
|
|
children: children);
|
|
}
|
|
|
|
final List<Outline> children;
|
|
final Range codeRange;
|
|
final Element element;
|
|
final Range range;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['element'] =
|
|
element?.toJson() ?? (throw 'element is required but was not set');
|
|
__result['range'] =
|
|
range?.toJson() ?? (throw 'range is required but was not set');
|
|
__result['codeRange'] =
|
|
codeRange?.toJson() ?? (throw 'codeRange is required but was not set');
|
|
if (children != null) {
|
|
__result['children'] = children.map((item) => item.toJson()).toList();
|
|
}
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('element');
|
|
try {
|
|
if (!obj.containsKey('element')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['element'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Element.canParse(obj['element'], reporter))) {
|
|
reporter.reportError('must be of type Element');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('range');
|
|
try {
|
|
if (!obj.containsKey('range')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['range'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Range.canParse(obj['range'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('codeRange');
|
|
try {
|
|
if (!obj.containsKey('codeRange')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['codeRange'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Range.canParse(obj['codeRange'], reporter))) {
|
|
reporter.reportError('must be of type Range');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('children');
|
|
try {
|
|
if (obj['children'] != null &&
|
|
!((obj['children'] is List &&
|
|
(obj['children']
|
|
.every((item) => Outline.canParse(item, reporter)))))) {
|
|
reporter.reportError('must be of type List<Outline>');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type Outline');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is Outline && other.runtimeType == Outline) {
|
|
return element == other.element &&
|
|
range == other.range &&
|
|
codeRange == other.codeRange &&
|
|
listEqual(
|
|
children, other.children, (Outline a, Outline b) => a == b) &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, element.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, range.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, codeRange.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, lspHashCode(children));
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class PublishClosingLabelsParams implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
PublishClosingLabelsParams.canParse, PublishClosingLabelsParams.fromJson);
|
|
|
|
PublishClosingLabelsParams({@required this.uri, @required this.labels}) {
|
|
if (uri == null) {
|
|
throw 'uri is required but was not provided';
|
|
}
|
|
if (labels == null) {
|
|
throw 'labels is required but was not provided';
|
|
}
|
|
}
|
|
static PublishClosingLabelsParams fromJson(Map<String, dynamic> json) {
|
|
final uri = json['uri'];
|
|
final labels = json['labels']
|
|
?.map((item) => item != null ? ClosingLabel.fromJson(item) : null)
|
|
?.cast<ClosingLabel>()
|
|
?.toList();
|
|
return PublishClosingLabelsParams(uri: uri, labels: labels);
|
|
}
|
|
|
|
final List<ClosingLabel> labels;
|
|
final String uri;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['uri'] = uri ?? (throw 'uri is required but was not set');
|
|
__result['labels'] = labels?.map((item) => item.toJson())?.toList() ??
|
|
(throw 'labels is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('uri');
|
|
try {
|
|
if (!obj.containsKey('uri')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['uri'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['uri'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('labels');
|
|
try {
|
|
if (!obj.containsKey('labels')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['labels'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!((obj['labels'] is List &&
|
|
(obj['labels']
|
|
.every((item) => ClosingLabel.canParse(item, reporter)))))) {
|
|
reporter.reportError('must be of type List<ClosingLabel>');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type PublishClosingLabelsParams');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is PublishClosingLabelsParams &&
|
|
other.runtimeType == PublishClosingLabelsParams) {
|
|
return uri == other.uri &&
|
|
listEqual(labels, other.labels,
|
|
(ClosingLabel a, ClosingLabel b) => a == b) &&
|
|
true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, uri.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, lspHashCode(labels));
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class PublishFlutterOutlineParams implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
PublishFlutterOutlineParams.canParse,
|
|
PublishFlutterOutlineParams.fromJson);
|
|
|
|
PublishFlutterOutlineParams({@required this.uri, @required this.outline}) {
|
|
if (uri == null) {
|
|
throw 'uri is required but was not provided';
|
|
}
|
|
if (outline == null) {
|
|
throw 'outline is required but was not provided';
|
|
}
|
|
}
|
|
static PublishFlutterOutlineParams fromJson(Map<String, dynamic> json) {
|
|
final uri = json['uri'];
|
|
final outline = json['outline'] != null
|
|
? FlutterOutline.fromJson(json['outline'])
|
|
: null;
|
|
return PublishFlutterOutlineParams(uri: uri, outline: outline);
|
|
}
|
|
|
|
final FlutterOutline outline;
|
|
final String uri;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['uri'] = uri ?? (throw 'uri is required but was not set');
|
|
__result['outline'] =
|
|
outline?.toJson() ?? (throw 'outline is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('uri');
|
|
try {
|
|
if (!obj.containsKey('uri')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['uri'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['uri'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('outline');
|
|
try {
|
|
if (!obj.containsKey('outline')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['outline'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(FlutterOutline.canParse(obj['outline'], reporter))) {
|
|
reporter.reportError('must be of type FlutterOutline');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type PublishFlutterOutlineParams');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is PublishFlutterOutlineParams &&
|
|
other.runtimeType == PublishFlutterOutlineParams) {
|
|
return uri == other.uri && outline == other.outline && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, uri.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, outline.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|
|
|
|
class PublishOutlineParams implements ToJsonable {
|
|
static const jsonHandler = LspJsonHandler(
|
|
PublishOutlineParams.canParse, PublishOutlineParams.fromJson);
|
|
|
|
PublishOutlineParams({@required this.uri, @required this.outline}) {
|
|
if (uri == null) {
|
|
throw 'uri is required but was not provided';
|
|
}
|
|
if (outline == null) {
|
|
throw 'outline is required but was not provided';
|
|
}
|
|
}
|
|
static PublishOutlineParams fromJson(Map<String, dynamic> json) {
|
|
final uri = json['uri'];
|
|
final outline =
|
|
json['outline'] != null ? Outline.fromJson(json['outline']) : null;
|
|
return PublishOutlineParams(uri: uri, outline: outline);
|
|
}
|
|
|
|
final Outline outline;
|
|
final String uri;
|
|
|
|
Map<String, dynamic> toJson() {
|
|
var __result = <String, dynamic>{};
|
|
__result['uri'] = uri ?? (throw 'uri is required but was not set');
|
|
__result['outline'] =
|
|
outline?.toJson() ?? (throw 'outline is required but was not set');
|
|
return __result;
|
|
}
|
|
|
|
static bool canParse(Object obj, LspJsonReporter reporter) {
|
|
if (obj is Map<String, dynamic>) {
|
|
reporter.push('uri');
|
|
try {
|
|
if (!obj.containsKey('uri')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['uri'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(obj['uri'] is String)) {
|
|
reporter.reportError('must be of type String');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
reporter.push('outline');
|
|
try {
|
|
if (!obj.containsKey('outline')) {
|
|
reporter.reportError('must not be undefined');
|
|
return false;
|
|
}
|
|
if (obj['outline'] == null) {
|
|
reporter.reportError('must not be null');
|
|
return false;
|
|
}
|
|
if (!(Outline.canParse(obj['outline'], reporter))) {
|
|
reporter.reportError('must be of type Outline');
|
|
return false;
|
|
}
|
|
} finally {
|
|
reporter.pop();
|
|
}
|
|
return true;
|
|
} else {
|
|
reporter.reportError('must be of type PublishOutlineParams');
|
|
return false;
|
|
}
|
|
}
|
|
|
|
@override
|
|
bool operator ==(Object other) {
|
|
if (other is PublishOutlineParams &&
|
|
other.runtimeType == PublishOutlineParams) {
|
|
return uri == other.uri && outline == other.outline && true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
@override
|
|
int get hashCode {
|
|
var hash = 0;
|
|
hash = JenkinsSmiHash.combine(hash, uri.hashCode);
|
|
hash = JenkinsSmiHash.combine(hash, outline.hashCode);
|
|
return JenkinsSmiHash.finish(hash);
|
|
}
|
|
|
|
@override
|
|
String toString() => jsonEncoder.convert(toJson());
|
|
}
|