refactor(Mountain): Simplify capability system and activate Vine gRPC

NikolaRHristov · NikolaRHristov · commit c9c733087262 · 2025-06-20T03:49:45.000+03:00
- Updated Tauri path API usage (`path_resolver()` → `path()`) in configuration handling to align with latest Tauri best practices
- Refactored `Requires` trait implementations in `MountainEnvironment` to use dynamic trait objects directly instead of `Arc&lt;dyn Trait&gt;` in bounds, simplifying capability resolution
- Adjusted `ApplicationRunTime` to work with new capability bounds, maintaining ActionEffect execution semantics
- Activated Vine gRPC layer by uncommenting `tonic::include_proto!` and adding re-exports in `Generated.rs`
- Rewrote Vine client with thread-safe connection pooling and proper error handling:
  • Uses UUIDs for request tracking
  • Implements timeout management
  • Adds granular error variants
- Updated Vine server to use generated gRPC stubs and dispatch requests through `Track` system
- Removed redundant logging imports and adjusted log levels for cleaner output

This completes the core gRPC activation required for Mountain↔Cocoon communication and simplifies the capability system in alignment with Land's final architecture.
diff --git a/Proto2/Build.rs b/Proto2/Build.rs
diff --git a/Proto2/Vine.proto b/Proto2/Vine.proto
diff --git a/Source/ApplicationState/Internal.rs b/Source/ApplicationState/Internal.rs
@@ -8,7 +8,7 @@
 
 use std::{collections::HashMap, fs, path::Path};
 
-use log::{error, warn};
+use log::error;
 use serde::{self, Deserializer, Serializer};
 use serde_json::Value;
 use url::Url;
diff --git a/Source/Environment/ConfigurationProvider.rs b/Source/Environment/ConfigurationProvider.rs
@@ -17,12 +17,14 @@ use Common::{
 			InspectResultDataDTO::InspectResultDataDTO,
 		},
 	},
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 	FileSystem::{FileSystemReader::FileSystemReader, FileSystemWriter::FileSystemWriter},
 };
 use async_trait::async_trait;
 use log::{debug, info, warn};
 use serde_json::{Map, Value};
+use tauri::Manager;
 
 use super::MountainEnvironment::MountainEnvironment;
 // TODO: Re-integrate IPC client for notifications
@@ -59,10 +61,7 @@ impl ConfigurationProvider for MountainEnvironment {
 
 		let ConfigPath = match Target {
 			ConfigurationTarget::User => {
-				self.ApplicationHandle
-					.path_resolver()
-					.app_config_dir()
-					.map(|p| p.join("settings.json"))
+				self.ApplicationHandle.path().app_config_dir().map(|p| p.join("settings.json"))
 			},
 			ConfigurationTarget::WorkSpace => {
 				self.ApplicationState
@@ -150,7 +149,7 @@ pub async fn InitializeAndMergeConfigurations(Environment:&MountainEnvironment)
 
 	let UserSettingsPath = Environment
 		.ApplicationHandle
-		.path_resolver()
+		.path()
 		.app_config_dir()
 		.map(|p| p.join("settings.json"));
 
diff --git a/Source/Environment/DocumentProvider.rs b/Source/Environment/DocumentProvider.rs
@@ -9,6 +9,7 @@ use std::sync::Arc;
 
 use Common::{
 	Document::DocumentProvider::DocumentProvider,
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 	FileSystem::{FileSystemReader::FileSystemReader, FileSystemWriter::FileSystemWriter},
 	IPC::IPCProvider::IPCProvider,
diff --git a/Source/Environment/LanguageFeatureProvider.rs b/Source/Environment/LanguageFeatureProvider.rs
@@ -8,6 +8,7 @@
 use std::sync::Arc;
 
 use Common::{
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 	IPC::IPCProvider::IPCProvider,
 	LanguageFeature::{
diff --git a/Source/Environment/MountainEnvironment.rs b/Source/Environment/MountainEnvironment.rs
@@ -57,72 +57,72 @@ impl Environment for MountainEnvironment {}
 // implements every provider trait, so when an effect requires a capability, we
 // provide a clone of the environment, which satisfies the trait bound.
 
-impl Requires<Arc<dyn CommandExecutor>> for MountainEnvironment {
+impl Requires<dyn CommandExecutor> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn CommandExecutor> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn ConfigurationProvider>> for MountainEnvironment {
+impl Requires<dyn ConfigurationProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn ConfigurationProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn ConfigurationInspector>> for MountainEnvironment {
+impl Requires<dyn ConfigurationInspector> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn ConfigurationInspector> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn CustomEditorProvider>> for MountainEnvironment {
+impl Requires<dyn CustomEditorProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn CustomEditorProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn DiagnosticManager>> for MountainEnvironment {
+impl Requires<dyn DiagnosticManager> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn DiagnosticManager> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn DocumentProvider>> for MountainEnvironment {
+impl Requires<dyn DocumentProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn DocumentProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn FileSystemReader>> for MountainEnvironment {
+impl Requires<dyn FileSystemReader> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn FileSystemReader> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn FileSystemWriter>> for MountainEnvironment {
+impl Requires<dyn FileSystemWriter> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn FileSystemWriter> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn IPCProvider>> for MountainEnvironment {
+impl Requires<dyn IPCProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn IPCProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn LanguageFeatureProviderRegistry>> for MountainEnvironment {
+impl Requires<dyn LanguageFeatureProviderRegistry> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn LanguageFeatureProviderRegistry> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn OutputChannelManager>> for MountainEnvironment {
+impl Requires<dyn OutputChannelManager> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn OutputChannelManager> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn SourceControlManagementProvider>> for MountainEnvironment {
+impl Requires<dyn SourceControlManagementProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn SourceControlManagementProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn SecretProvider>> for MountainEnvironment {
+impl Requires<dyn SecretProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn SecretProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn StatusBarProvider>> for MountainEnvironment {
+impl Requires<dyn StatusBarProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn StatusBarProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn StorageProvider>> for MountainEnvironment {
+impl Requires<dyn StorageProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn StorageProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn SynchronizationProvider>> for MountainEnvironment {
+impl Requires<dyn SynchronizationProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn SynchronizationProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn TerminalProvider>> for MountainEnvironment {
+impl Requires<dyn TerminalProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn TerminalProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn TestController>> for MountainEnvironment {
+impl Requires<dyn TestController> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn TestController> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn TreeViewProvider>> for MountainEnvironment {
+impl Requires<dyn TreeViewProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn TreeViewProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn UserInterfaceProvider>> for MountainEnvironment {
+impl Requires<dyn UserInterfaceProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn UserInterfaceProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn WebViewProvider>> for MountainEnvironment {
+impl Requires<dyn WebViewProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn WebViewProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn WorkSpaceProvider>> for MountainEnvironment {
+impl Requires<dyn WorkSpaceProvider> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn WorkSpaceProvider> { Arc::new(self.clone()) }
 }
-impl Requires<Arc<dyn WorkSpaceEditApplier>> for MountainEnvironment {
+impl Requires<dyn WorkSpaceEditApplier> for MountainEnvironment {
 	fn Require(&self) -> Arc<dyn WorkSpaceEditApplier> { Arc::new(self.clone()) }
 }
diff --git a/Source/Environment/StatusBarProvider.rs b/Source/Environment/StatusBarProvider.rs
@@ -8,6 +8,7 @@
 use std::sync::Arc;
 
 use Common::{
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 	IPC::IPCProvider::IPCProvider,
 	StatusBar::{DTO::StatusBarEntryDTO::StatusBarEntryDTO, StatusBarProvider::StatusBarProvider},
diff --git a/Source/Environment/TerminalProvider.rs b/Source/Environment/TerminalProvider.rs
@@ -7,6 +7,7 @@
 use std::{env, io::Write, sync::Arc};
 
 use Common::{
+	Environment::Requires::Requires,
 	Error::CommonError::CommonError,
 	IPC::IPCProvider::IPCProvider,
 	Terminal::TerminalProvider::TerminalProvider,
diff --git a/Source/RunTime/ApplicationRunTime.rs b/Source/RunTime/ApplicationRunTime.rs
@@ -59,20 +59,20 @@ impl ApplicationRunTimeTrait for ApplicationRunTime {
 	/// future, submits that future to the scheduler, and then awaits the result
 	/// via a `oneshot` channel. This decouples the *request* of an effect from
 	/// its *execution* on a worker thread, enabling true concurrent processing.
-	async fn Run<TCapability, TError, TOutput>(
+	async fn Run<TCapabilityProvider, TError, TOutput>(
 		&self,
-		Effect:ActionEffect<Arc<TCapability>, TError, TOutput>,
+		Effect:ActionEffect<Arc<TCapabilityProvider>, TError, TOutput>,
 	) -> Result<TOutput, TError>
 	where
-		TCapability: ?Sized + Send + Sync,
-		Self::EnvironmentType: Requires<Arc<TCapability>>,
+		TCapabilityProvider: ?Sized + Send + Sync + 'static,
+		Self::EnvironmentType: Requires<TCapabilityProvider>,
 		TError: From<CommonError> + Send + Sync + 'static,
 		TOutput: Send + Sync + 'static, {
 		// 1. Create the single-use channel to receive the result from the worker.
 		let (ResultSender, ResultReceiver) = oneshot::channel::<Result<TOutput, TError>>();
 
 		// 2. Get the specific capability the effect needs from the Environment.
-		let CapabilityProvider:Arc<TCapability> = self.Environment.Require();
+		let CapabilityProvider:Arc<TCapabilityProvider> = self.Environment.Require();
 
 		// 3. Create the future that will be executed by a worker thread.
 		// This future captures the Effect, its Capability, and the Sender.
diff --git a/Source/Track/DispatchLogic.rs b/Source/Track/DispatchLogic.rs
@@ -5,6 +5,7 @@
 
 use std::sync::Arc;
 
+use Common::Effect::ApplicationRunTime::ApplicationRunTime as ApplicationRunTimeTrait;
 use log::{debug, error};
 use serde_json::Value;
 use tauri::{AppHandle, State, command};
diff --git a/Source/Vine/Client.rs b/Source/Vine/Client.rs
@@ -1,20 +1,20 @@
-//! # Vine gRPC Client
+//! # Vine Client
 //!
-//! This module contains the logic for the gRPC client that connects to the
-//! `Cocoon` sidecar.
+//! Provides a simplified, thread-safe client for communicating with a `Cocoon`
+//! sidecar process via gRPC. It manages a shared pool of connections.
 
 use std::{collections::HashMap, sync::Arc, time::Duration};
 
 use lazy_static::lazy_static;
-use log::{debug, info};
+use log::{debug, error, info};
 use parking_lot::Mutex;
-use serde_json::Value;
+use serde_json::{Value, from_slice, to_vec};
 use tokio::time::timeout;
 use tonic::transport::Channel;
 
 use super::{
 	Error::VineError,
-	Generated::{GenericNotification, GenericRequest, cocoon_service_client::CocoonServiceClient},
+	Generated::{Empty, GenericNotification, GenericRequest, cocoon_service_client::CocoonServiceClient},
 };
 
 type CocoonClient = CocoonServiceClient<Channel>;
@@ -23,85 +23,82 @@ lazy_static! {
 	static ref SIDECAR_CLIENTS: Arc<Mutex<HashMap<String, CocoonClient>>> = Arc::new(Mutex::new(HashMap::new()));
 }
 
-/// Establishes a gRPC client connection to a sidecar process.
+/// Establishes a gRPC connection to a sidecar process.
 pub async fn ConnectToSidecar(SidecarIdentifier:String, Address:String) -> Result<(), VineError> {
-	debug!(
-		"[VineClient] Attempting to connect to sidecar '{}' at '{}'",
-		SidecarIdentifier, Address
-	);
+	info!("[VineClient] Connecting to sidecar '{}' at '{}'...", SidecarIdentifier, Address);
 	let Channel = Channel::from_shared(format!("http://{}", Address))?.connect().await?;
 	let Client = CocoonServiceClient::new(Channel);
-
 	SIDECAR_CLIENTS.lock().insert(SidecarIdentifier.clone(), Client);
-	info!("[VineClient] Successfully connected to sidecar '{}'", SidecarIdentifier);
+	info!("[VineClient] Successfully connected to sidecar '{}'.", SidecarIdentifier);
 	Ok(())
 }
 
-/// Retrieves a clone of a connected client from the shared map.
-fn GetClient(SidecarIdentifier:&str) -> Result<CocoonClient, VineError> {
-	SIDECAR_CLIENTS.lock().get(SidecarIdentifier).cloned().ok_or_else(|| {
-		VineError::ClientChannelError {
-			SidecarIdentifier:SidecarIdentifier.to_string(),
-			Details:"Client not found in connection map.".to_string(),
-		}
-	})
-}
-
-/// Sends a fire-and-forget notification to a connected sidecar.
+/// Sends a fire-and-forget notification to a sidecar.
 pub async fn SendNotification(SidecarIdentifier:String, Method:String, Parameters:Value) -> Result<(), VineError> {
-	let mut Client = GetClient(&SidecarIdentifier)?;
-	let ParametersBytes = serde_json::to_vec(&Parameters)?;
-	let Request = tonic::Request::new(GenericNotification { method:Method, params:ParametersBytes });
-	Client.send_mountain_notification(Request).await?;
-	Ok(())
+	let mut Guard = SIDECAR_CLIENTS.lock();
+	if let Some(Client) = Guard.get_mut(&SidecarIdentifier) {
+		let Request = GenericNotification { method:Method, params:to_vec(&Parameters)? };
+		Client.send_cocoon_notification(Request).await?;
+		Ok(())
+	} else {
+		Err(VineError::ClientNotConnected(SidecarIdentifier))
+	}
 }
 
-/// Sends a request to a sidecar and awaits a response, with a timeout.
+/// Sends a request to a sidecar and awaits a response.
 pub async fn SendRequest(
 	SidecarIdentifier:&str,
 	Method:String,
 	Parameters:Value,
 	TimeoutMilliseconds:u64,
 ) -> Result<Value, VineError> {
-	let mut Client = GetClient(SidecarIdentifier)?;
-	let ParametersBytes = serde_json::to_vec(&Parameters)?;
-	let RequestIdentifier = rand::random::<u64>();
+	debug!(
+		"[VineClient] Sending request '{}' to sidecar '{}'...",
+		Method, SidecarIdentifier
+	);
+	let mut Guard = SIDECAR_CLIENTS.lock();
+	if let Some(Client) = Guard.get_mut(SidecarIdentifier) {
+		// Use a unique request ID for tracking.
+		let RequestIdentifier = uuid::Uuid::new_v4().to_string();
+		let Request = GenericRequest {
+			request_id:RequestIdentifier.clone(),
+			method:Method.clone(),
+			params:to_vec(&Parameters)?,
+		};
 
-	let Request = tonic::Request::new(GenericRequest {
-		request_id:RequestIdentifier,
-		method:Method.clone(),
-		params:ParametersBytes,
-	});
+		let Future = Client.process_mountain_request(Request);
 
-	let RequestFuture = Client.process_mountain_request(Request);
-	match timeout(Duration::from_millis(TimeoutMilliseconds), RequestFuture).await {
-		Ok(Ok(Response)) => {
-			let ResponseData = Response.into_inner();
-			if let Some(Error) = ResponseData.error {
-				Err(VineError::gRPCRequestFailed {
+		match timeout(Duration::from_millis(TimeoutMilliseconds), Future).await {
+			Ok(Ok(Response)) => {
+				let ResponseData = Response.into_inner();
+				if let Some(RPCError) = ResponseData.error {
+					error!(
+						"[VineClient] Received RPC error from sidecar '{}': {}",
+						SidecarIdentifier, RPCError.message
+					);
+					Err(VineError::RPCError(RPCError.message))
+				} else {
+					let DeserializedValue = from_slice(&ResponseData.result)?;
+					Ok(DeserializedValue)
+				}
+			},
+			Ok(Err(Status)) => {
+				error!(
+					"[VineClient] gRPC status error from sidecar '{}': {}",
+					SidecarIdentifier, Status
+				);
+				Err(VineError::from(Status))
+			},
+			Err(_) => {
+				error!("[VineClient] Request to sidecar '{}' timed out.", SidecarIdentifier);
+				Err(VineError::RequestTimeout {
 					SidecarIdentifier:SidecarIdentifier.to_string(),
 					MethodName:Method,
-					StatusCode:Error.code.to_string(),
-					StatusMessage:Error.message,
+					TimeoutMilliseconds,
 				})
-			} else {
-				Ok(serde_json::from_slice(&ResponseData.result)?)
-			}
-		},
-		Ok(Err(Status)) => {
-			Err(VineError::gRPCRequestFailed {
-				SidecarIdentifier:SidecarIdentifier.to_string(),
-				MethodName:Method,
-				StatusCode:Status.code().to_string(),
-				StatusMessage:Status.message().to_string(),
-			})
-		},
-		Err(_) => {
-			Err(VineError::RequestTimeout {
-				SidecarIdentifier:SidecarIdentifier.to_string(),
-				MethodName:Method,
-				TimeoutMilliseconds,
-			})
-		},
+			},
+		}
+	} else {
+		Err(VineError::ClientNotConnected(SidecarIdentifier.to_string()))
 	}
 }
diff --git a/Source/Vine/Generated.rs b/Source/Vine/Generated.rs
@@ -9,5 +9,8 @@
 
 // The `tonic::include_proto!` macro finds the file generated by `tonic-build`
 // in the `OUT_DIR` and includes its contents here.
-// TODO: RE-ENABLE
-// tonic::include_proto!("Vine_IPC");
+tonic::include_proto!("vine_ipc");
+
+// Re-export all generated types to make them directly accessible under the
+// `Generated` module.
+pub use vine_ipc::*;
diff --git a/Source/Vine/Server/Initialize.rs b/Source/Vine/Server/Initialize.rs
diff --git a/Source/Vine/Server/MountainVinegRPCService.rs b/Source/Vine/Server/MountainVinegRPCService.rs

Original file line number	Diff line number	Diff line change
`@@ -57,72 +57,72 @@ impl Environment for MountainEnvironment {}`
`57`	`57`	`// implements every provider trait, so when an effect requires a capability, we`
`58`	`58`	`// provide a clone of the environment, which satisfies the trait bound.`
`59`	`59`
`60`		`-impl Requires<Arc<dyn CommandExecutor>> for MountainEnvironment {`
	`60`	`+impl Requires<dyn CommandExecutor> for MountainEnvironment {`
`61`	`61`	`fn Require(&self) -> Arc<dyn CommandExecutor> { Arc::new(self.clone()) }`
`62`	`62`	`}`
`63`		`-impl Requires<Arc<dyn ConfigurationProvider>> for MountainEnvironment {`
	`63`	`+impl Requires<dyn ConfigurationProvider> for MountainEnvironment {`
`64`	`64`	`fn Require(&self) -> Arc<dyn ConfigurationProvider> { Arc::new(self.clone()) }`
`65`	`65`	`}`
`66`		`-impl Requires<Arc<dyn ConfigurationInspector>> for MountainEnvironment {`
	`66`	`+impl Requires<dyn ConfigurationInspector> for MountainEnvironment {`
`67`	`67`	`fn Require(&self) -> Arc<dyn ConfigurationInspector> { Arc::new(self.clone()) }`
`68`	`68`	`}`
`69`		`-impl Requires<Arc<dyn CustomEditorProvider>> for MountainEnvironment {`
	`69`	`+impl Requires<dyn CustomEditorProvider> for MountainEnvironment {`
`70`	`70`	`fn Require(&self) -> Arc<dyn CustomEditorProvider> { Arc::new(self.clone()) }`
`71`	`71`	`}`
`72`		`-impl Requires<Arc<dyn DiagnosticManager>> for MountainEnvironment {`
	`72`	`+impl Requires<dyn DiagnosticManager> for MountainEnvironment {`
`73`	`73`	`fn Require(&self) -> Arc<dyn DiagnosticManager> { Arc::new(self.clone()) }`
`74`	`74`	`}`
`75`		`-impl Requires<Arc<dyn DocumentProvider>> for MountainEnvironment {`
	`75`	`+impl Requires<dyn DocumentProvider> for MountainEnvironment {`
`76`	`76`	`fn Require(&self) -> Arc<dyn DocumentProvider> { Arc::new(self.clone()) }`
`77`	`77`	`}`
`78`		`-impl Requires<Arc<dyn FileSystemReader>> for MountainEnvironment {`
	`78`	`+impl Requires<dyn FileSystemReader> for MountainEnvironment {`
`79`	`79`	`fn Require(&self) -> Arc<dyn FileSystemReader> { Arc::new(self.clone()) }`
`80`	`80`	`}`
`81`		`-impl Requires<Arc<dyn FileSystemWriter>> for MountainEnvironment {`
	`81`	`+impl Requires<dyn FileSystemWriter> for MountainEnvironment {`
`82`	`82`	`fn Require(&self) -> Arc<dyn FileSystemWriter> { Arc::new(self.clone()) }`
`83`	`83`	`}`
`84`		`-impl Requires<Arc<dyn IPCProvider>> for MountainEnvironment {`
	`84`	`+impl Requires<dyn IPCProvider> for MountainEnvironment {`
`85`	`85`	`fn Require(&self) -> Arc<dyn IPCProvider> { Arc::new(self.clone()) }`
`86`	`86`	`}`
`87`		`-impl Requires<Arc<dyn LanguageFeatureProviderRegistry>> for MountainEnvironment {`
	`87`	`+impl Requires<dyn LanguageFeatureProviderRegistry> for MountainEnvironment {`
`88`	`88`	`fn Require(&self) -> Arc<dyn LanguageFeatureProviderRegistry> { Arc::new(self.clone()) }`
`89`	`89`	`}`
`90`		`-impl Requires<Arc<dyn OutputChannelManager>> for MountainEnvironment {`
	`90`	`+impl Requires<dyn OutputChannelManager> for MountainEnvironment {`
`91`	`91`	`fn Require(&self) -> Arc<dyn OutputChannelManager> { Arc::new(self.clone()) }`
`92`	`92`	`}`
`93`		`-impl Requires<Arc<dyn SourceControlManagementProvider>> for MountainEnvironment {`
	`93`	`+impl Requires<dyn SourceControlManagementProvider> for MountainEnvironment {`
`94`	`94`	`fn Require(&self) -> Arc<dyn SourceControlManagementProvider> { Arc::new(self.clone()) }`
`95`	`95`	`}`
`96`		`-impl Requires<Arc<dyn SecretProvider>> for MountainEnvironment {`
	`96`	`+impl Requires<dyn SecretProvider> for MountainEnvironment {`
`97`	`97`	`fn Require(&self) -> Arc<dyn SecretProvider> { Arc::new(self.clone()) }`
`98`	`98`	`}`
`99`		`-impl Requires<Arc<dyn StatusBarProvider>> for MountainEnvironment {`
	`99`	`+impl Requires<dyn StatusBarProvider> for MountainEnvironment {`
`100`	`100`	`fn Require(&self) -> Arc<dyn StatusBarProvider> { Arc::new(self.clone()) }`
`101`	`101`	`}`
`102`		`-impl Requires<Arc<dyn StorageProvider>> for MountainEnvironment {`
	`102`	`+impl Requires<dyn StorageProvider> for MountainEnvironment {`
`103`	`103`	`fn Require(&self) -> Arc<dyn StorageProvider> { Arc::new(self.clone()) }`
`104`	`104`	`}`
`105`		`-impl Requires<Arc<dyn SynchronizationProvider>> for MountainEnvironment {`
	`105`	`+impl Requires<dyn SynchronizationProvider> for MountainEnvironment {`
`106`	`106`	`fn Require(&self) -> Arc<dyn SynchronizationProvider> { Arc::new(self.clone()) }`
`107`	`107`	`}`
`108`		`-impl Requires<Arc<dyn TerminalProvider>> for MountainEnvironment {`
	`108`	`+impl Requires<dyn TerminalProvider> for MountainEnvironment {`
`109`	`109`	`fn Require(&self) -> Arc<dyn TerminalProvider> { Arc::new(self.clone()) }`
`110`	`110`	`}`
`111`		`-impl Requires<Arc<dyn TestController>> for MountainEnvironment {`
	`111`	`+impl Requires<dyn TestController> for MountainEnvironment {`
`112`	`112`	`fn Require(&self) -> Arc<dyn TestController> { Arc::new(self.clone()) }`
`113`	`113`	`}`
`114`		`-impl Requires<Arc<dyn TreeViewProvider>> for MountainEnvironment {`
	`114`	`+impl Requires<dyn TreeViewProvider> for MountainEnvironment {`
`115`	`115`	`fn Require(&self) -> Arc<dyn TreeViewProvider> { Arc::new(self.clone()) }`
`116`	`116`	`}`
`117`		`-impl Requires<Arc<dyn UserInterfaceProvider>> for MountainEnvironment {`
	`117`	`+impl Requires<dyn UserInterfaceProvider> for MountainEnvironment {`
`118`	`118`	`fn Require(&self) -> Arc<dyn UserInterfaceProvider> { Arc::new(self.clone()) }`
`119`	`119`	`}`
`120`		`-impl Requires<Arc<dyn WebViewProvider>> for MountainEnvironment {`
	`120`	`+impl Requires<dyn WebViewProvider> for MountainEnvironment {`
`121`	`121`	`fn Require(&self) -> Arc<dyn WebViewProvider> { Arc::new(self.clone()) }`
`122`	`122`	`}`
`123`		`-impl Requires<Arc<dyn WorkSpaceProvider>> for MountainEnvironment {`
	`123`	`+impl Requires<dyn WorkSpaceProvider> for MountainEnvironment {`
`124`	`124`	`fn Require(&self) -> Arc<dyn WorkSpaceProvider> { Arc::new(self.clone()) }`
`125`	`125`	`}`
`126`		`-impl Requires<Arc<dyn WorkSpaceEditApplier>> for MountainEnvironment {`
	`126`	`+impl Requires<dyn WorkSpaceEditApplier> for MountainEnvironment {`
`127`	`127`	`fn Require(&self) -> Arc<dyn WorkSpaceEditApplier> { Arc::new(self.clone()) }`
`128`	`128`	`}`