warning: returning the result of a `let` binding from a block
   --> crates/gui/src/main.rs:237:17
    |
195 | /                 let debugger = match request.as_str() {
196 | |                     "attach" => {
197 | |                         let launch_arguments = AttachArguments {
198 | |                             working_directory: debug_root_dir.to_owned().to_path_buf(),
...   |
235 | |                     _ => todo!(),
236 | |                 };
    | |__________________- unnecessary `let` binding
237 |                   debugger
    |                   ^^^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#let_and_return
    = note: `#[warn(clippy::let_and_return)]` on by default
help: return the expression directly
    |
195 ~                 
196 ~                 match request.as_str() {
197 +                     "attach" => {
198 +                         let launch_arguments = AttachArguments {
199 +                             working_directory: debug_root_dir.to_owned().to_path_buf(),
200 +                             port: connect.map(|c| c.port),
201 +                             language: debugger::Language::DebugPy,
202 +                             path_mappings,
203 +                         };
204 + 
205 +                         tracing::debug!(?launch_arguments, "generated launch configuration");
206 + 
207 +                         Debugger::new(launch_arguments).context("creating internal debugger")?
208 +                     }
209 +                     "launch" => {
210 +                         let Some(program) = program else {
211 +                             eyre::bail!("'program' is a required setting");
212 +                         };
213 +                         let launch_arguments = LaunchArguments {
214 +                             program: program.clone(),
215 +                             working_directory: Some(debug_root_dir.to_owned().to_path_buf()),
216 +                             language: debugger::Language::DebugPy,
217 +                         };
218 + 
219 +                         tracing::debug!(?launch_arguments, "generated launch configuration");
220 +                         let debugger = debugger::Debugger::new(launch_arguments)
221 +                             .context("creating internal debugger")?;
222 + 
223 +                         for line in args.breakpoints {
224 +                             let breakpoint = debugger::Breakpoint {
225 +                                 path: program.clone(),
226 +                                 line,
227 +                                 ..Default::default()
228 +                             };
229 +                             debugger
230 +                                 .add_breakpoint(&breakpoint)
231 +                                 .context("adding breakpoint")?;
232 +                         }
233 + 
234 +                         debugger
235 +                     }
236 +                     _ => todo!(),
237 +                 }
    |

warning: this `if` statement can be collapsed
  --> crates/gui/src/ui/call_stack.rs:32:17
   |
32 | /                 if ui.link(frame.name.to_string()).clicked() {
33 | |                     if let Err(e) = self.state.change_scope(frame.id) {
34 | |                         tracing::warn!(error = ?e, "error changing scope");
35 | |                     }
36 | |                 }
   | |_________________^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#collapsible_if
   = note: `#[warn(clippy::collapsible_if)]` on by default
help: collapse nested if block
   |
32 ~                 if ui.link(frame.name.to_string()).clicked()
33 ~                     && let Err(e) = self.state.change_scope(frame.id) {
34 |                         tracing::warn!(error = ?e, "error changing scope");
35 ~                     }
   |

warning: returning the result of a `let` binding from a block
  --> crates/gui2/src/debugger_app.rs:99:13
   |
84 | /             let debugger = match request.as_str() {
85 | |                 "attach" => {
86 | |                     let launch_arguments = AttachArguments {
87 | |                         working_directory: debug_root_dir.to_owned().to_path_buf(),
...  |
97 | |                 _ => todo!(),
98 | |             };
   | |______________- unnecessary `let` binding
99 |               debugger
   |               ^^^^^^^^
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#let_and_return
   = note: `#[warn(clippy::let_and_return)]` on by default
help: return the expression directly
   |
84 ~             
85 ~             match request.as_str() {
86 +                 "attach" => {
87 +                     let launch_arguments = AttachArguments {
88 +                         working_directory: debug_root_dir.to_owned().to_path_buf(),
89 +                         port: connect.map(|c| c.port),
90 +                         language: debugger::Language::DebugPy,
91 +                         path_mappings,
92 +                     };
93 + 
94 +                     tracing::debug!(?launch_arguments, "generated launch configuration");
95 + 
96 +                     Debugger::new(launch_arguments).context("creating internal debugger")?
97 +                 }
98 +                 _ => todo!(),
99 +             }
   |

warning: redundant closure
  --> crates/gui2/src/code_view/mod.rs:60:51
   |
60 |     let gutter: Element<'_, Message> = gutter.map(move |action| on_action(action));
   |                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `on_action`
   |
   = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#redundant_closure
   = note: `#[warn(clippy::redundant_closure)]` on by default

warning: returning the result of a `let` binding from a block
   --> crates/pythondap/src/debugger.rs:401:17
    |
370 | /                 let debugger = match request.as_str() {
371 | |                     "attach" => {
372 | |                         let launch_arguments = AttachArguments {
373 | |                             working_directory: debug_root_dir.to_owned().to_path_buf(),
...   |
399 | |                     other => todo!("Configuration type: '{other}' not implemented yet, or invalid"),
400 | |                 };
    | |__________________- unnecessary `let` binding
401 |                   debugger
    |                   ^^^^^^^^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#let_and_return
    = note: `#[warn(clippy::let_and_return)]` on by default
help: return the expression directly
    |
370 ~                 
371 ~                 match request.as_str() {
372 +                     "attach" => {
373 +                         let launch_arguments = AttachArguments {
374 +                             working_directory: debug_root_dir.to_owned().to_path_buf(),
375 +                             port: connect.map(|c| c.port),
376 +                             language: debugger::Language::DebugPy,
377 +                             path_mappings,
378 +                         };
379 + 
380 +                         tracing::debug!(?launch_arguments, "generated launch configuration");
381 + 
382 +                         debugger::Debugger::on_port(port, launch_arguments).map_err(|e| {
383 +                             PyRuntimeError::new_err(format!("creating internal debugger: {e}"))
384 +                         })?
385 +                     }
386 +                     "launch" => {
387 +                         let launch_arguments = LaunchArguments {
388 +                             program: program.ok_or_else(|| {
389 +                                 PyRuntimeError::new_err("program is a required argument")
390 +                             })?,
391 +                             working_directory: Some(debug_root_dir.to_owned().to_path_buf()),
392 +                             language: debugger::Language::DebugPy,
393 +                         };
394 + 
395 +                         tracing::debug!(?launch_arguments, "generated launch configuration");
396 +                         debugger::Debugger::on_port(port, launch_arguments).map_err(|e| {
397 +                             PyRuntimeError::new_err(format!("creating internal debugger: {e}"))
398 +                         })?
399 +                     }
400 +                     other => todo!("Configuration type: '{other}' not implemented yet, or invalid"),
401 +                 }
    |

warning: associated items `new`, `add`, and `handle_response` are never used
  --> crates/debugger/src/pending_requests.rs:21:19
   |
19 | impl PendingRequests {
   | -------------------- associated items in this implementation
20 |     /// Create a new pending requests tracker
21 |     pub(crate) fn new() -> Self {
   |                   ^^^
...
30 |     pub(crate) fn add(&mut self, seq: Seq) -> oneshot::Receiver<responses::Response> {
   |                   ^^^
...
40 |     pub(crate) fn handle_response(&mut self, response: responses::Response) -> bool {
   |                   ^^^^^^^^^^^^^^^

warning: associated items `from_split_connection_no_channel`, `on_event_nonblocking`, `on_follow_up_response`, `handle_stack_trace_response`, `handle_scopes_response`, and `handle_variables_response` are never used
   --> crates/debugger/src/internals.rs:153:19
    |
103 | impl DebuggerInternals {
    | ---------------------- associated items in this implementation
...
153 |     pub(crate) fn from_split_connection_no_channel(
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
692 |     pub(crate) fn on_event_nonblocking(
    |                   ^^^^^^^^^^^^^^^^^^^^
...
737 |     pub(crate) fn on_follow_up_response(
    |                   ^^^^^^^^^^^^^^^^^^^^^
...
755 |     fn handle_stack_trace_response(
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
...
837 |     fn handle_scopes_response(
    |        ^^^^^^^^^^^^^^^^^^^^^^
...
863 |     fn handle_variables_response(
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: fields `body` and `response_tx` are never read
  --> crates/debugger/src/commands.rs:32:9
   |
31 |     SendExecute {
   |     ----------- fields in this variant
32 |         body: requests::RequestBody,
   |         ^^^^
33 |         response_tx: oneshot::Sender<eyre::Result<()>>,
   |         ^^^^^^^^^^^
   |
   = note: `Command` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis

warning: fields `body` and `response_tx` are never read
  --> crates/debugger/src/commands.rs:22:9
   |
21 |     SendRequest {
   |     ----------- fields in this variant
22 |         body: requests::RequestBody,
   |         ^^^^
23 |         response_tx: oneshot::Sender<eyre::Result<responses::Response>>,
   |         ^^^^^^^^^^^
   |
   = note: `Command` has a derived impl for the trait `Debug`, but this is intentionally ignored during dead code analysis
   = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default

warning: unused variable: `command_rx`
   --> crates/debugger/src/debugger.rs:204:26
    |
204 |         let (command_tx, command_rx) = crossbeam_channel::unbounded();
    |                          ^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_command_rx`
    |
    = note: `#[warn(unused_variables)]` (part of `#[warn(unused)]`) on by default

warning: very complex type used. Consider factoring parts into `type` definitions
   --> crates/transport/src/client.rs:427:10
    |
427 |       ) -> (
    |  __________^
428 | |         reader::hand_written_reader::HandWrittenReader<Box<dyn BufRead + Send>>,
429 | |         Box<dyn Write + Send>,
430 | |         Arc<AtomicI64>,
431 | |     ) {
    | |_____^
    |
    = help: for further information visit https://rust-lang.github.io/rust-clippy/beta/index.html#type_complexity
    = note: `#[warn(clippy::type_complexity)]` on by default