pkg/dtd/lib/src/dart_tooling_daemon.dart - sdk.git - Git at Google

 // Copyright (c) 2023, 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.

 import 'dart:async';
 import 'dart:convert';

 import 'package:json_rpc_2/json_rpc_2.dart';
 import 'package:stream_channel/stream_channel.dart';
 import 'package:web_socket_channel/web_socket_channel.dart';

 import '../dtd.dart';

 typedef DTDServiceCallback = Future<Map<String, Object?>> Function(
   Parameters params,
 );

 // TODO(danchevalier): add a serviceMethodIsAvailable experience. it will listen
 // to a stream that announces servicemethods getting registered and
 // unregistered. The state can then be presented as a listenable so that clients
 // can gate their behaviour on a serviceMethod going up/down.

 /// A connection to a Dart Tooling Daemon instance.
 ///
 /// The base interactions for Dart Tooling Daemon are found here.
 class DartToolingDaemon {
   /// Connects to a Dart Tooling Daemon instance over the provided
   /// [streamChannel].
   ///
   /// To over a WebSocket, the [DartToolingDaemon.connect] helper can be used.
   DartToolingDaemon.fromStreamChannel(StreamChannel<String> streamChannel)
       : _clientPeer = Peer(streamChannel) {
     _clientPeer.registerMethod('streamNotify', (Parameters params) {
       final streamId = params['streamId'].asString;
       final eventKind = params['eventKind'].asString;
       final eventData = params['eventData'].asMap as Map<String, Object?>;
       final timestamp = params['timestamp'].asInt;

       _subscribedStreamControllers[streamId]?.add(
         DTDEvent(
           streamId,
           eventKind,
           eventData,
           timestamp,
         ),
       );
     });

     _done = _clientPeer.listen();
   }

   /// Connects to a Dart Tooling Daemon instance.
   ///
   /// ```dart
   /// final uri = Uri.parse('ws://127.0.0.1:59247/em6ZgeqMpvV8tOKg');
   /// final client = DartToolingDaemon.connect(uri);
   /// ```
   static Future<DartToolingDaemon> connect(Uri uri) async {
     final channel = WebSocketChannel.connect(uri);
     await channel.ready;
     return DartToolingDaemon.fromStreamChannel(channel.cast<String>());
   }

   late final Peer _clientPeer;
   late final Future<void> _done;
   final _subscribedStreamControllers = <String, StreamController<DTDEvent>>{};

   /// Terminates the connection with the Dart Tooling Daemon.
   Future<void> close() => _clientPeer.close();

   /// A [Future] that completes when the connection with the Dart Tooling Daemon
   /// is terminated.
   Future<void> get done => _done;

   /// Whether or not the connection is closed.
   bool get isClosed => _clientPeer.isClosed;

   /// Registers this client as the handler for the [service].[method] service
   /// method.
   ///
   /// An optional map of [capabilities] can be supplied that will be provided
   /// to clients listening for `ServiceRegistered` events. The use of this field
   /// is service method specific.
   ///
   /// If the [service] has already been registered by another client, then an
   /// [RpcException] with [RpcErrorCodes.kServiceAlreadyRegistered] is thrown.
   /// Only one client at a time may register to a [service]. Once a client
   /// disconnects then another client may register services under than name.
   ///
   /// If the [method] has already been registered on the [service], then an
   /// [RpcException] with [RpcErrorCodes.kServiceMethodAlreadyRegistered] is
   /// thrown.
   Future<void> registerService(
     String service,
     String method,
     DTDServiceCallback callback, {
     Map<String, Object?>? capabilities,
   }) async {
     final combinedName = '$service.$method';
     await _clientPeer.sendRequest('registerService', {
       'service': service,
       'method': method,
       if (capabilities != null) 'capabilities': capabilities,
     });

     _clientPeer.registerMethod(
       combinedName,
       callback,
     );
   }

   /// Subscribes this client to events posted on [streamId].
   ///
   /// Once called, the Dart Tooling Daemon will then send any events on the
   /// [streamId] to this instance of [DartToolingDaemon]. See [onEvent] for
   /// details on how to get access to that [Stream] of [DTDEvent]s.
   ///
   /// If this client is already subscribed to [streamId], an [RpcException] with
   /// [RpcErrorCodes.kStreamAlreadySubscribed] will be thrown.
   Future<void> streamListen(String streamId) {
     return _clientPeer.sendRequest(
       'streamListen',
       {
         'streamId': streamId,
       },
     );
   }

   /// Cancel the subscription to [streamId].
   ///
   /// Once called, this connection will no longer receive events posted on
   /// [streamId].
   ///
   /// If this client was not subscribed to [streamId], an [RpcException] with
   /// [RpcErrorCodes.kStreamNotSubscribed] will be thrown.
   Future<void> streamCancel(String streamId) {
     return _clientPeer.sendRequest(
       'streamCancel',
       {
         'streamId': streamId,
       },
     );
   }

   /// Returns a broadcast [Stream] for events received on [streamId].
   ///
   /// This method should be called and a listener added before calling
   /// [streamListen] to ensure events aren't dropped.
   Stream<DTDEvent> onEvent(String streamId) {
     return _subscribedStreamControllers
         .putIfAbsent(
           streamId,
           StreamController<DTDEvent>.broadcast,
         )
         .stream;
   }

   /// Posts a [DTDEvent] with [eventData] to [streamId].
   ///
   /// The Dart Tooling Daemon will forward the [DTDEvent] to all clients that
   /// have subscribed to [streamId] by calling [streamListen].
   ///
   /// If no clients are listening to [streamId], the event will be dropped.
   Future<void> postEvent(
     String streamId,
     String eventKind,
     Map<String, Object?> eventData,
   ) async {
     await _clientPeer.sendRequest(
       'postEvent',
       {
         'streamId': streamId,
         'eventKind': eventKind,
         'eventData': eventData,
       },
     );
   }

   /// Invokes the service method registered with the name
   /// `[serviceName].[methodName]`.
   ///
   /// If provided, [params] will be sent as the set of parameters used when
   /// invoking the service.
   ///
   /// If `[serviceName].[methodName]` is not a registered service method, an
   /// [RpcException] will be thrown with [RpcErrorCodes.kMethodNotFound].
   ///
   /// If the parameters included in [params] are invalid, an [RpcException] will
   /// be thrown with [RpcErrorCodes.kInvalidParams].
   Future<DTDResponse> call(
     String serviceName,
     String methodName, {
     Map<String, Object?>? params,
   }) async {
     final json = await _clientPeer.sendRequest(
       '$serviceName.$methodName',
       params ?? <String, Object?>{},
     ) as Map<String, Object?>;

     final type = json['type'] as String?;
     if (type == null) {
       throw DartToolingDaemonConnectionException.callResponseMissingType(json);
     }

     // TODO(danchevalier): Find out how to get access to the id.
     return DTDResponse('-1', type, json);
   }

   /// Reads the file at [uri] from disk in the environment where the Dart
   /// Tooling Daemon is running.
   ///
   /// If [uri] is not contained in the IDE workspace roots, then an
   /// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
   ///
   /// If [uri] does not exist, then an [RpcException] exception with error
   /// code [RpcErrorCodes.kFileDoesNotExist] is thrown.
   ///
   /// If [uri] does not have a file scheme, then an [RpcException] with
   /// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
   Future<FileContent> readFileAsString(
     Uri uri, {
     Encoding encoding = utf8,
   }) async {
     final result = await call(
       kFileSystemServiceName,
       'readFileAsString',
       params: {
         'uri': uri.toString(),
         'encoding': encoding.name,
       },
     );
     return FileContent.fromDTDResponse(result);
   }

   /// Writes [contents] to the file at [uri] in the environment where the Dart
   /// Tooling Daemon is running.
   ///
   /// The file will be created if it does not exist, and it will be overwritten
   /// if it already exist.
   ///
   /// If [uri] is not contained in the IDE workspace roots, then an
   /// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
   ///
   /// If [uri] does not have a file scheme, then an [RpcException] with
   /// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
   Future<void> writeFileAsString(
     Uri uri,
     String contents, {
     Encoding encoding = utf8,
   }) async {
     await call(
       kFileSystemServiceName,
       'writeFileAsString',
       params: {
         'uri': uri.toString(),
         'contents': contents,
         'encoding': encoding.name,
       },
     );
   }

   /// Lists the directories and files under the directory at [uri] in the
   /// environment where the Dart Tooling Daemon is running.
   ///
   /// If [uri] is not a directory, throws an [RpcException] exception with error
   /// code [RpcErrorCodes.kDirectoryDoesNotExist].
   ///
   /// If [uri] is not contained in the IDE workspace roots, then an
   /// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
   ///
   /// If [uri] does not have a file scheme, then an [RpcException] with
   /// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
   ///
   /// The returned uris will be `file://` Uris.
   Future<UriList> listDirectoryContents(Uri uri) async {
     final result = await call(
       kFileSystemServiceName,
       'listDirectoryContents',
       params: {
         'uri': uri.toString(),
       },
     );
     return UriList.fromDTDResponse(result);
   }

   /// Sets the IDE workspace roots for the FileSystem service.
   ///
   /// This is a privileged RPC that require's a [secret], which is provided by
   /// the Dart Tooling Daemon, to be called successfully. This secret is
   /// generated by the daemon and provided to its spawner to ensure only trusted
   /// clients can set workspace roots. If [secret] is invalid, an [RpcException]
   /// with error code [RpcErrorCodes.kPermissionDenied] is thrown.
   ///
   /// If [secret] does not match the secret created when Dart Tooling Daemon was
   /// created, then an [RpcException] with [RpcErrorCodes.kPermissionDenied] is
   /// thrown.
   ///
   /// If one of the [roots] is missing a "file" scheme then an [RpcException]
   /// with [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
   Future<void> setIDEWorkspaceRoots(String secret, List<Uri> roots) async {
     await call(
       kFileSystemServiceName,
       'setIDEWorkspaceRoots',
       params: {
         'roots': roots.map<String>((e) => e.toString()).toList(),
         'secret': secret,
       },
     );
   }

   /// Gets the IDE workspace roots for the FileSystem service.
   ///
   /// The returned uris will be `file://` Uris.
   Future<IDEWorkspaceRoots> getIDEWorkspaceRoots() async {
     final result = await call(
       kFileSystemServiceName,
       'getIDEWorkspaceRoots',
     );
     return IDEWorkspaceRoots.fromDTDResponse(result);
   }

   /// Gets the project roots contained within the current set of IDE workspace
   /// roots.
   ///
   /// A project root is any directory that contains a 'pubspec.yaml' file. If
   /// IDE workspace roots are not set, or if there are no project roots within
   /// the IDE workspace roots, this method will return an empty [UriList].
   ///
   /// [depth] is the maximum depth that each IDE workspace root directory tree
   /// will be searched for project roots.
   ///
   /// The returned uris will be `file://` Uris.
   Future<UriList> getProjectRoots({
     int depth = defaultGetProjectRootsDepth,
   }) async {
     final result = await call(
       kFileSystemServiceName,
       'getProjectRoots',
       params: {'depth': depth},
     );
     return UriList.fromDTDResponse(result);
   }
 }

 /// Represents the response of an RPC call to the Dart Tooling Daemon.
 class DTDResponse {
   DTDResponse(this._id, this._type, this._result);

   DTDResponse.fromDTDResponse(DTDResponse other)
       : this(
           other.id,
           other.type,
           other.result,
         );
   final String _id;
   final String _type;
   final Map<String, Object?> _result;

   String get id => _id;

   String get type => _type;

   Map<String, Object?> get result => _result;
 }

 /// A Dart Tooling Daemon stream event.
 class DTDEvent {
   DTDEvent(this.stream, this.kind, this.data, this.timestamp);
   String stream;
   int timestamp;
   String kind;
   Map<String, Object?> data;

   @override
   String toString() {
     return jsonEncode({
       'stream': stream,
       'timestamp': timestamp,
       'kind': kind,
       'data': data,
     });
   }
 }

 class DartToolingDaemonConnectionException implements Exception {
   static const int callParamsMissingTypeError = 1;

   /// The response to a call method is missing the top level type parameter.
   factory DartToolingDaemonConnectionException.callResponseMissingType(
     Map<String, Object?> json,
   ) {
     return DartToolingDaemonConnectionException._(
       callParamsMissingTypeError,
       'call received an invalid response, '
       "it is missing the 'type' param. Got: $json",
     );
   }
   DartToolingDaemonConnectionException._(this.errorCode, this.message);

   @override
   String toString() => 'DartToolingDaemonConnectionException: $message';

   final int errorCode;
   final String message;
 }
	// Copyright (c) 2023, 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.

	import 'dart:async';
	import 'dart:convert';

	import 'package:json_rpc_2/json_rpc_2.dart';
	import 'package:stream_channel/stream_channel.dart';
	import 'package:web_socket_channel/web_socket_channel.dart';

	import '../dtd.dart';

	typedef DTDServiceCallback = Future<Map<String, Object?>> Function(
	Parameters params,
	);

	// TODO(danchevalier): add a serviceMethodIsAvailable experience. it will listen
	// to a stream that announces servicemethods getting registered and
	// unregistered. The state can then be presented as a listenable so that clients
	// can gate their behaviour on a serviceMethod going up/down.

	/// A connection to a Dart Tooling Daemon instance.
	///
	/// The base interactions for Dart Tooling Daemon are found here.
	class DartToolingDaemon {
	/// Connects to a Dart Tooling Daemon instance over the provided
	/// [streamChannel].
	///
	/// To over a WebSocket, the [DartToolingDaemon.connect] helper can be used.
	DartToolingDaemon.fromStreamChannel(StreamChannel<String> streamChannel)
	: _clientPeer = Peer(streamChannel) {
	_clientPeer.registerMethod('streamNotify', (Parameters params) {
	final streamId = params['streamId'].asString;
	final eventKind = params['eventKind'].asString;
	final eventData = params['eventData'].asMap as Map<String, Object?>;
	final timestamp = params['timestamp'].asInt;

	_subscribedStreamControllers[streamId]?.add(
	DTDEvent(
	streamId,
	eventKind,
	eventData,
	timestamp,
	),
	);
	});

	_done = _clientPeer.listen();
	}

	/// Connects to a Dart Tooling Daemon instance.
	///
	/// ```dart
	/// final uri = Uri.parse('ws://127.0.0.1:59247/em6ZgeqMpvV8tOKg');
	/// final client = DartToolingDaemon.connect(uri);
	/// ```
	static Future<DartToolingDaemon> connect(Uri uri) async {
	final channel = WebSocketChannel.connect(uri);
	await channel.ready;
	return DartToolingDaemon.fromStreamChannel(channel.cast<String>());
	}

	late final Peer _clientPeer;
	late final Future<void> _done;
	final _subscribedStreamControllers = <String, StreamController<DTDEvent>>{};

	/// Terminates the connection with the Dart Tooling Daemon.
	Future<void> close() => _clientPeer.close();

	/// A [Future] that completes when the connection with the Dart Tooling Daemon
	/// is terminated.
	Future<void> get done => _done;

	/// Whether or not the connection is closed.
	bool get isClosed => _clientPeer.isClosed;

	/// Registers this client as the handler for the [service].[method] service
	/// method.
	///
	/// An optional map of [capabilities] can be supplied that will be provided
	/// to clients listening for `ServiceRegistered` events. The use of this field
	/// is service method specific.
	///
	/// If the [service] has already been registered by another client, then an
	/// [RpcException] with [RpcErrorCodes.kServiceAlreadyRegistered] is thrown.
	/// Only one client at a time may register to a [service]. Once a client
	/// disconnects then another client may register services under than name.
	///
	/// If the [method] has already been registered on the [service], then an
	/// [RpcException] with [RpcErrorCodes.kServiceMethodAlreadyRegistered] is
	/// thrown.
	Future<void> registerService(
	String service,
	String method,
	DTDServiceCallback callback, {
	Map<String, Object?>? capabilities,
	}) async {
	final combinedName = '$service.$method';
	await _clientPeer.sendRequest('registerService', {
	'service': service,
	'method': method,
	if (capabilities != null) 'capabilities': capabilities,
	});

	_clientPeer.registerMethod(
	combinedName,
	callback,
	);
	}

	/// Subscribes this client to events posted on [streamId].
	///
	/// Once called, the Dart Tooling Daemon will then send any events on the
	/// [streamId] to this instance of [DartToolingDaemon]. See [onEvent] for
	/// details on how to get access to that [Stream] of [DTDEvent]s.
	///
	/// If this client is already subscribed to [streamId], an [RpcException] with
	/// [RpcErrorCodes.kStreamAlreadySubscribed] will be thrown.
	Future<void> streamListen(String streamId) {
	return _clientPeer.sendRequest(
	'streamListen',
	{
	'streamId': streamId,
	},
	);
	}

	/// Cancel the subscription to [streamId].
	///
	/// Once called, this connection will no longer receive events posted on
	/// [streamId].
	///
	/// If this client was not subscribed to [streamId], an [RpcException] with
	/// [RpcErrorCodes.kStreamNotSubscribed] will be thrown.
	Future<void> streamCancel(String streamId) {
	return _clientPeer.sendRequest(
	'streamCancel',
	{
	'streamId': streamId,
	},
	);
	}

	/// Returns a broadcast [Stream] for events received on [streamId].
	///
	/// This method should be called and a listener added before calling
	/// [streamListen] to ensure events aren't dropped.
	Stream<DTDEvent> onEvent(String streamId) {
	return _subscribedStreamControllers
	.putIfAbsent(
	streamId,
	StreamController<DTDEvent>.broadcast,
	)
	.stream;
	}

	/// Posts a [DTDEvent] with [eventData] to [streamId].
	///
	/// The Dart Tooling Daemon will forward the [DTDEvent] to all clients that
	/// have subscribed to [streamId] by calling [streamListen].
	///
	/// If no clients are listening to [streamId], the event will be dropped.
	Future<void> postEvent(
	String streamId,
	String eventKind,
	Map<String, Object?> eventData,
	) async {
	await _clientPeer.sendRequest(
	'postEvent',
	{
	'streamId': streamId,
	'eventKind': eventKind,
	'eventData': eventData,
	},
	);
	}

	/// Invokes the service method registered with the name
	/// `[serviceName].[methodName]`.
	///
	/// If provided, [params] will be sent as the set of parameters used when
	/// invoking the service.
	///
	/// If `[serviceName].[methodName]` is not a registered service method, an
	/// [RpcException] will be thrown with [RpcErrorCodes.kMethodNotFound].
	///
	/// If the parameters included in [params] are invalid, an [RpcException] will
	/// be thrown with [RpcErrorCodes.kInvalidParams].
	Future<DTDResponse> call(
	String serviceName,
	String methodName, {
	Map<String, Object?>? params,
	}) async {
	final json = await _clientPeer.sendRequest(
	'$serviceName.$methodName',
	params ?? <String, Object?>{},
	) as Map<String, Object?>;

	final type = json['type'] as String?;
	if (type == null) {
	throw DartToolingDaemonConnectionException.callResponseMissingType(json);
	}

	// TODO(danchevalier): Find out how to get access to the id.
	return DTDResponse('-1', type, json);
	}

	/// Reads the file at [uri] from disk in the environment where the Dart
	/// Tooling Daemon is running.
	///
	/// If [uri] is not contained in the IDE workspace roots, then an
	/// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
	///
	/// If [uri] does not exist, then an [RpcException] exception with error
	/// code [RpcErrorCodes.kFileDoesNotExist] is thrown.
	///
	/// If [uri] does not have a file scheme, then an [RpcException] with
	/// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
	Future<FileContent> readFileAsString(
	Uri uri, {
	Encoding encoding = utf8,
	}) async {
	final result = await call(
	kFileSystemServiceName,
	'readFileAsString',
	params: {
	'uri': uri.toString(),
	'encoding': encoding.name,
	},
	);
	return FileContent.fromDTDResponse(result);
	}

	/// Writes [contents] to the file at [uri] in the environment where the Dart
	/// Tooling Daemon is running.
	///
	/// The file will be created if it does not exist, and it will be overwritten
	/// if it already exist.
	///
	/// If [uri] is not contained in the IDE workspace roots, then an
	/// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
	///
	/// If [uri] does not have a file scheme, then an [RpcException] with
	/// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
	Future<void> writeFileAsString(
	Uri uri,
	String contents, {
	Encoding encoding = utf8,
	}) async {
	await call(
	kFileSystemServiceName,
	'writeFileAsString',
	params: {
	'uri': uri.toString(),
	'contents': contents,
	'encoding': encoding.name,
	},
	);
	}

	/// Lists the directories and files under the directory at [uri] in the
	/// environment where the Dart Tooling Daemon is running.
	///
	/// If [uri] is not a directory, throws an [RpcException] exception with error
	/// code [RpcErrorCodes.kDirectoryDoesNotExist].
	///
	/// If [uri] is not contained in the IDE workspace roots, then an
	/// [RpcException] with [RpcErrorCodes.kPermissionDenied] is thrown.
	///
	/// If [uri] does not have a file scheme, then an [RpcException] with
	/// [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
	///
	/// The returned uris will be `file://` Uris.
	Future<UriList> listDirectoryContents(Uri uri) async {
	final result = await call(
	kFileSystemServiceName,
	'listDirectoryContents',
	params: {
	'uri': uri.toString(),
	},
	);
	return UriList.fromDTDResponse(result);
	}

	/// Sets the IDE workspace roots for the FileSystem service.
	///
	/// This is a privileged RPC that require's a [secret], which is provided by
	/// the Dart Tooling Daemon, to be called successfully. This secret is
	/// generated by the daemon and provided to its spawner to ensure only trusted
	/// clients can set workspace roots. If [secret] is invalid, an [RpcException]
	/// with error code [RpcErrorCodes.kPermissionDenied] is thrown.
	///
	/// If [secret] does not match the secret created when Dart Tooling Daemon was
	/// created, then an [RpcException] with [RpcErrorCodes.kPermissionDenied] is
	/// thrown.
	///
	/// If one of the [roots] is missing a "file" scheme then an [RpcException]
	/// with [RpcErrorCodes.kExpectsUriParamWithFileScheme] is thrown.
	Future<void> setIDEWorkspaceRoots(String secret, List<Uri> roots) async {
	await call(
	kFileSystemServiceName,
	'setIDEWorkspaceRoots',
	params: {
	'roots': roots.map<String>((e) => e.toString()).toList(),
	'secret': secret,
	},
	);
	}

	/// Gets the IDE workspace roots for the FileSystem service.
	///
	/// The returned uris will be `file://` Uris.
	Future<IDEWorkspaceRoots> getIDEWorkspaceRoots() async {
	final result = await call(
	kFileSystemServiceName,
	'getIDEWorkspaceRoots',
	);
	return IDEWorkspaceRoots.fromDTDResponse(result);
	}

	/// Gets the project roots contained within the current set of IDE workspace
	/// roots.
	///
	/// A project root is any directory that contains a 'pubspec.yaml' file. If
	/// IDE workspace roots are not set, or if there are no project roots within
	/// the IDE workspace roots, this method will return an empty [UriList].
	///
	/// [depth] is the maximum depth that each IDE workspace root directory tree
	/// will be searched for project roots.
	///
	/// The returned uris will be `file://` Uris.
	Future<UriList> getProjectRoots({
	int depth = defaultGetProjectRootsDepth,
	}) async {
	final result = await call(
	kFileSystemServiceName,
	'getProjectRoots',
	params: {'depth': depth},
	);
	return UriList.fromDTDResponse(result);
	}
	}

	/// Represents the response of an RPC call to the Dart Tooling Daemon.
	class DTDResponse {
	DTDResponse(this._id, this._type, this._result);

	DTDResponse.fromDTDResponse(DTDResponse other)
	: this(
	other.id,
	other.type,
	other.result,
	);
	final String _id;
	final String _type;
	final Map<String, Object?> _result;

	String get id => _id;

	String get type => _type;

	Map<String, Object?> get result => _result;
	}

	/// A Dart Tooling Daemon stream event.
	class DTDEvent {
	DTDEvent(this.stream, this.kind, this.data, this.timestamp);
	String stream;
	int timestamp;
	String kind;
	Map<String, Object?> data;

	@override
	String toString() {
	return jsonEncode({
	'stream': stream,
	'timestamp': timestamp,
	'kind': kind,
	'data': data,
	});
	}
	}

	class DartToolingDaemonConnectionException implements Exception {
	static const int callParamsMissingTypeError = 1;

	/// The response to a call method is missing the top level type parameter.
	factory DartToolingDaemonConnectionException.callResponseMissingType(
	Map<String, Object?> json,
	) {
	return DartToolingDaemonConnectionException._(
	callParamsMissingTypeError,
	'call received an invalid response, '
	"it is missing the 'type' param. Got: $json",
	);
	}
	DartToolingDaemonConnectionException._(this.errorCode, this.message);

	@override
	String toString() => 'DartToolingDaemonConnectionException: $message';

	final int errorCode;
	final String message;
	}