You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: channels.rs
    path of file: ./repos/erg/crates/els
    
    the code of the file until where you have to start completion: use std::sync::mpsc;

use erg_compiler::artifact::BuildRunnable;
use erg_compiler::erg_parser::parse::Parsable;

use lsp_types::request::{
    CallHierarchyIncomingCalls, CallHierarchyOutgoingCalls, CallHierarchyPrepare,
    CodeActionRequest, CodeActionResolveRequest, CodeLensRequest, Completion,
    DocumentSymbolRequest, ExecuteCommand, FoldingRangeRequest, GotoDefinition, GotoImplementation,
    GotoImplementationParams, HoverRequest, InlayHintRequest, InlayHintResolveRequest, References,
    ResolveCompletionItem, SemanticTokensFullRequest, SignatureHelpRequest, WillRenameFiles,
    WorkspaceSymbol,
};
use lsp_types::{
    CallHierarchyIncomingCallsParams, CallHierarchyOutgoingCallsParams, CallHierarchyPrepareParams,
    CodeAction, CodeActionParams, CodeLensParams, CompletionItem, CompletionParams,
    DocumentSymbolParams, ExecuteCommandParams, FoldingRangeParams, GotoDefinitionParams,
    HoverParams, InlayHint, InlayHintParams, ReferenceParams, RenameFilesParams,
    SemanticTokensParams, SignatureHelpParams, WorkspaceSymbolParams,
};

use crate::server::Server;

#[derive(Debug, Clone)]
pub enum WorkerMessage<P> {
    Request(i64, P),
    Kill,
}

impl<P> From<(i64, P)> for WorkerMessage<P> {
    fn from((id, params): (i64, P)) -> Self {
        Self::Request(id, params)
    }
}

#[derive(Debug, Clone)]
pub struct SendChannels {
    completion: mpsc::Sender<WorkerMessage<CompletionParams>>,
    resolve_completion: mpsc::Sender<WorkerMessage<CompletionItem>>,
    goto_definition: mpsc::Sender<WorkerMessage<GotoDefinitionParams>>,
    goto_implementation: mpsc::Sender<WorkerMessage<GotoImplementationParams>>,
    semantic_tokens_full: mpsc::Sender<WorkerMessage<SemanticTokensParams>>,
    inlay_hint: mpsc::Sender<WorkerMessage<InlayHintParams>>,
    inlay_hint_resolve: mpsc::Sender<WorkerMessage<InlayHint>>,
    hover: mpsc::Sender<WorkerMessage<HoverParams>>,
    references: mpsc::Sender<WorkerMessage<ReferenceParams>>,
    code_lens: mpsc::Sender<WorkerMessage<CodeLensParams>>,
    code_action: mpsc::Sender<WorkerMessage<CodeActionParams>>,
    code_action_resolve: mpsc::Sender<WorkerMessage<CodeAction>>,
    signature_help: mpsc::Sender<WorkerMessage<SignatureHelpParams>>,
    will_rename_files: mpsc::Sender<WorkerMessage<RenameFilesParams>>,
    execute_command: mpsc::Sender<WorkerMessage<ExecuteCommandParams>>,
    workspace_symbol: mpsc::Sender<WorkerMessage<WorkspaceSymbolParams>>,
    document_symbol: mpsc::Sender<WorkerMessage<DocumentSymbolParams>>,
    call_hierarchy_prepare: mpsc::Sender<WorkerMessage<CallHierarchyPrepareParams>>,
    call_hierarchy_incoming: mpsc::Sender<WorkerMessage<CallHi
    
    pub fn new() -> (Self, ReceiveChannels) {
        let (tx_completion, rx_completion) = mpsc::channel();
        let (tx_resolve_completion, rx_resolve_completion) = mpsc::channel();
        let (tx_goto_definition, rx_goto_definition) = mpsc::channel();
        let (tx_goto_implementation, rx_goto_implementation) = mpsc::channel();
        let (tx_semantic_tokens_full, rx_semantic_tokens_full) = mpsc::channel();
        let (tx_inlay_hint, rx_inlay_hint) = mpsc::channel();
        let (tx_inlay_hint_resolve, rx_inlay_hint_resolve) = mpsc::channel();
        let (tx_hover, rx_hover) = mpsc::channel();
        let (tx_references, rx_references) = mpsc::channel();
        let (tx_code_lens, rx_code_lens) = mpsc::channel();
        let (tx_code_action, rx_code_action) = mpsc::channel();
        let (tx_code_action_resolve, rx_code_action_resolve) = mpsc::channel();
        let (tx_sig_help, rx_sig_help) = mpsc::channel();
        let (tx_will_rename_files, rx_will_rename_files) = mpsc::channel();
        let (tx_execute_command, rx_execute_command) = mpsc::channel();
        let (tx_workspace_symbol, rx_workspace_symbol) = mpsc::channel();
        let (tx_document_symbol, rx_document_symbol) = mpsc::channel();
        let (tx_call_hierarchy_prepare, rx_call_hierarchy_prepare) = mpsc::channel();
        let (tx_call_hierarchy_incoming, rx_call_hierarchy_incoming) = mpsc::channel();
        let (tx_call_hierarchy_outgoing, rx_call_hierarchy_outgoing) = mpsc::channel();
        let (tx_folding_range, rx_folding_range) = mpsc::channel();
        let (tx_health_check, rx_health_check) = mpsc::channel();
        (
            Self {
                completion: tx_completion,
                resolve_completion: tx_resolve_completion,
                goto_definition: tx_goto_definition,
                goto_implementation: tx_goto_implementation,
                semantic_tokens_full: tx_semantic_tokens_full,
                inlay_hint: tx_inlay_hint,
                inlay_hint_resolve: tx_inlay_hint_resolve,
                hover: tx_hover,
                references: tx_references,
                code_lens: tx_code_lens,
                code_action: tx_code_action,
                code_action_resolve: tx_code_action_resolve,
                signature_help: tx_sig_help,
                will_rename_files: tx_will_rename_files,
                execute_command: tx_execute_command,
                workspace_symbol: tx_workspace_symbol,
                document_symbol: tx_document_symbol,
                call_hierarchy_prepare: tx_call_hierarchy_prepare,
                call_hierarchy_incoming: tx_call_hierarchy_incoming,
                call_hierarchy_outgoing: tx_call_hierarchy_outgoing,
                folding_range: tx_folding_range,
                health_check: tx_health_check,
            },
            ReceiveChannels {
                completion: rx_completion,
                resolve_completion: rx_resolve_completion,
                goto_definition: rx_goto_definition,
                goto_implementation: rx_goto_implementation,
                semantic_tokens_full: rx_semantic_tokens_full,
                inlay_hint: rx_inlay_hint,
                inlay_hint_resolve: rx_inlay_hint_resolve,
                hover: rx_hover,
                references: rx_references,
                code_lens: rx_code_lens,
                code_action: rx_code_action,
                code_action_resolve: rx_code_action_resolve,
                signature_help: rx_sig_help,
                will_rename_files: rx_will_rename_files,
                execute_command: rx_execute_command,
                workspace_symbol: rx_workspace_symbol,
                document_symbol: rx_document_symbol,
                call_hierarchy_prepare: rx_call_hierarchy_prepare,
                call_hierarchy_incoming: rx_call_hierarchy_incoming,
                call_hierarchy_outgoing: rx_call_hierarchy_outgoing,
                folding_range: rx_folding_range,
                health_check: rx_health_check,
            },
        )
    }