bcf70d8 · helix · git.iko.soy

284 Ok(())

285 }

286

287− pub async fn disconnect(&mut self) -> Result<()> {

287+ pub async fn disconnect(&self) -> Result<()> {

288 self.request::<requests::Disconnect>(()).await

289 }

290

297 }

298

299 pub async fn set_breakpoints(

300− &mut self,

300+ &self,

301 file: PathBuf,

302 breakpoints: Vec<SourceBreakpoint>,

303 ) -> Result<Option<Vec<Breakpoint>>> {

321 Ok(response.breakpoints)

322 }

323

324− pub async fn configuration_done(&mut self) -> Result<()> {

324+ pub async fn configuration_done(&self) -> Result<()> {

325 self.request::<requests::ConfigurationDone>(()).await

326 }

327

328− pub async fn continue_thread(&mut self, thread_id: ThreadId) -> Result<Option<bool>> {

328+ pub async fn continue_thread(&self, thread_id: ThreadId) -> Result<Option<bool>> {

329 let args = requests::ContinueArguments { thread_id };

330

331 let response = self.request::<requests::Continue>(args).await?;

333 }

334

335 pub async fn stack_trace(

336− &mut self,

336+ &self,

337 thread_id: ThreadId,

338 ) -> Result<(Vec<StackFrame>, Option<usize>)> {

339 let args = requests::StackTraceArguments {

347 Ok((response.stack_frames, response.total_frames))

348 }

349

350− pub async fn threads(&mut self) -> Result<Vec<Thread>> {

350+ pub async fn threads(&self) -> Result<Vec<Thread>> {

351 let response = self.request::<requests::Threads>(()).await?;

352 Ok(response.threads)

353 }

354

355− pub async fn scopes(&mut self, frame_id: usize) -> Result<Vec<Scope>> {

355+ pub async fn scopes(&self, frame_id: usize) -> Result<Vec<Scope>> {

356 let args = requests::ScopesArguments { frame_id };

357

358 let response = self.request::<requests::Scopes>(args).await?;

359 Ok(response.scopes)

360 }

361

362− pub async fn variables(&mut self, variables_reference: usize) -> Result<Vec<Variable>> {

362+ pub async fn variables(&self, variables_reference: usize) -> Result<Vec<Variable>> {

363 let args = requests::VariablesArguments {

364 variables_reference,

365 filter: None,

372 Ok(response.variables)

373 }

374

375− pub async fn step_in(&mut self, thread_id: ThreadId) -> Result<()> {

375+ pub async fn step_in(&self, thread_id: ThreadId) -> Result<()> {

376 let args = requests::StepInArguments {

377 thread_id,

378 target_id: None,

382 self.request::<requests::StepIn>(args).await

383 }

384

385− pub async fn step_out(&mut self, thread_id: ThreadId) -> Result<()> {

385+ pub async fn step_out(&self, thread_id: ThreadId) -> Result<()> {

386 let args = requests::StepOutArguments {

387 thread_id,

388 granularity: None,

391 self.request::<requests::StepOut>(args).await

392 }

393

394− pub async fn next(&mut self, thread_id: ThreadId) -> Result<()> {

394+ pub async fn next(&self, thread_id: ThreadId) -> Result<()> {

395 let args = requests::NextArguments {

396 thread_id,

397 granularity: None,

400 self.request::<requests::Next>(args).await

401 }

402

403− pub async fn pause(&mut self, thread_id: ThreadId) -> Result<()> {

403+ pub async fn pause(&self, thread_id: ThreadId) -> Result<()> {

404 let args = requests::PauseArguments { thread_id };

405

406 self.request::<requests::Pause>(args).await

407 }

408

409 pub async fn eval(

410− &mut self,

410+ &self,

411 expression: String,

412 frame_id: Option<usize>,

413 ) -> Result<requests::EvaluateResponse> {

422 }

423

424 pub async fn set_exception_breakpoints(

425− &mut self,

425+ &self,

426 filters: Vec<String>,

427 ) -> Result<Option<Vec<Breakpoint>>> {

428 let args = requests::SetExceptionBreakpointsArguments { filters };