Merge pull request #140 from Chia-Network/20250216-dbg-improvements

20250216 dbg improvements

Author: prozacchiwawa

test/classic-arg-decode.clsp

@@ -0,0 +1,7 @@
+(mod (X)
+  (defun F (X Y)
+    (if X (F (- X 1) Y) Y)
+    )
+
+  (F X 2)
+  )

test/classic-arg-decode.sym

@@ -0,0 +1 @@
+{"a63655f92a682296fe0afe6593b013f3d1ea5302438129dcd5af967af8e9b8f1":"F"}

test/launch.json

@@ -1,26 +1,26 @@
 {
     "version": "0.2.0",
     "configurations": [
-	    {
+	{
             "type": "chialisp",
             "request": "launch",
             "name": "fact.hex",
             "program": "project/fact.hex",
             "args": ["(5)"]
-	    },
+	},
         {
             "type": "chialisp",
             "request": "launch",
             "name": "fact.clsp - bad args",
             "program": "project/fact.clsp",
             "args": ["()"]
-	    },
+	},
         {
             "type": "chialisp",
             "request": "launch",
             "name": "fact.clsp",
             "program": "project/fact.clsp",
             "args": ["(5)"]
-	    }
+	}
     ]
 }

wasm/src/dbg/handler.rs

@@ -6,7 +6,7 @@ use std::mem::swap;
 use std::rc::Rc;
 
 use debug_types::events::{ContinuedEvent, Event, EventBody, StoppedEvent, StoppedReason};
-use debug_types::requests::{InitializeRequestArguments, LaunchRequestArguments, RequestCommand};
+use debug_types::requests::{InitializeRequestArguments, RequestCommand};
 use debug_types::responses::{
     InitializeResponse, Response, ResponseBody, ScopesResponse, SetBreakpointsResponse,
     SetExceptionBreakpointsResponse, StackTraceResponse, ThreadsResponse, VariablesResponse,
@@ -20,17 +20,17 @@ use clvmr::allocator::Allocator;
 
 use clvm_tools_rs::classic::clvm_tools::stages::stage_0::TRunProgram;
 
-use clvm_tools_rs::compiler::cldb_hierarchy::HierarchialRunner;
 use clvm_tools_rs::compiler::compiler::DefaultCompilerOpts;
-use clvm_tools_rs::compiler::sexp::{decode_string, parse_sexp, SExp};
+use clvm_tools_rs::compiler::sexp::{decode_string, SExp};
 use clvm_tools_rs::compiler::srcloc::Srcloc;
 
 use crate::dbg::compopts::DbgCompilerOpts;
-use crate::dbg::obj::{read_program_data, RunningDebugger, TargetDepth};
+use crate::dbg::obj::{ObjLaunchArgs, RunningDebugger, TargetDepth};
 use crate::dbg::source::{parse_srcloc, StoredScope};
 use crate::dbg::types::MessageHandler;
 use crate::interfaces::{IFileReader, ILogWriter};
 use crate::lsp::types::ConfigJson;
+
 // Lifecycle:
 // (a (code... ) (c arg ...))
 // We encounter this and we're creating the arguments for a future call to
@@ -49,6 +49,8 @@ pub struct ExtraLaunchData {
     args: Option<Vec<String>>,
     #[serde(rename = "program")]
     program: Option<String>,
+    #[serde(rename = "symbols")]
+    symbols: Option<String>,
 }
 
 /// Used to make some aspects of deserializing easier via serde_json easier.
@@ -59,6 +61,11 @@ pub struct RequestContainer<T> {
     arguments: T,
 }
 
+pub struct LaunchArgs<'a> {
+    proto_msg: &'a ProtocolMessage,
+    obj_launch_args: ObjLaunchArgs<'a>,
+}
+
 /// State diagram for the debugger.
 ///
 /// Starts in PreInitialization until we get an Initialization request.
@@ -180,16 +187,6 @@ fn get_initialize_response() -> InitializeResponse {
     }
 }
 
-struct LaunchArgs<'a> {
-    proto_msg: &'a ProtocolMessage,
-    name: &'a str,
-    init_args: &'a InitializeRequestArguments,
-    launch_request: &'a LaunchRequestArguments,
-    program: &'a str,
-    args_for_program: &'a [String],
-    stop_on_entry: bool,
-}
-
 impl Debugger {
     fn get_source_loc(&self, running: &RunningDebugger, name: &str) -> Option<Srcloc> {
         let get_helper_loc = |name: &str| {
@@ -249,64 +246,22 @@ impl Debugger {
         let mut allocator = Allocator::new();
         let mut seq_nr = self.msg_seq;
         let config = self.read_chialisp_json()?;
-        let read_in_file = self.fs.read_content(launch_args.program)?;
-        let def_opts = Rc::new(DefaultCompilerOpts::new(&launch_args.name));
+        let def_opts = Rc::new(DefaultCompilerOpts::new(&launch_args.obj_launch_args.name));
         let opts = Rc::new(DbgCompilerOpts::new(
             def_opts,
             self.log.clone(),
             self.fs.clone(),
             &config.include_paths,
         ));
-        let mut launch_data = read_program_data(
+        let debugger = RunningDebugger::create(
+            &mut allocator,
             self.fs.clone(),
             self.log.clone(),
-            &mut allocator,
+            self.runner.clone(),
             opts.clone(),
-            launch_args.init_args,
-            launch_args.launch_request,
-            launch_args.program,
-            read_in_file.as_bytes(),
+            &launch_args.obj_launch_args,
         )?;
-
-        if !launch_args.args_for_program.is_empty() {
-            let parsed_argv0 = parse_sexp(
-                Srcloc::start("*args*"),
-                launch_args.args_for_program[0].bytes(),
-            )
-            .map_err(|(l, e)| format!("{l}: {e}"))?;
-            if !parsed_argv0.is_empty() {
-                launch_data.arguments = parsed_argv0[0].clone();
-            }
-        }
-
-        let symbol_rc = Rc::new(launch_data.symbols);
-
-        let run = HierarchialRunner::new(
-            self.runner.clone(),
-            self.prim_map.clone(),
-            Some(launch_args.name.to_string()),
-            Rc::new(launch_data.program_lines),
-            symbol_rc.clone(),
-            launch_data.program,
-            launch_data.arguments,
-        );
-        let state = State::Launched(RunningDebugger {
-            initialized: launch_args.init_args.clone(),
-            launch_info: launch_args.launch_request.clone(),
-            running: !launch_args.stop_on_entry,
-            run,
-            opts,
-            output_stack: Vec::new(),
-            stopped_reason: None,
-            target_depth: None,
-            result: None,
-            source_file: launch_data.source_file,
-            compiled: launch_data.compiled,
-            breakpoints: HashMap::new(),
-            next_bp_id: 1,
-            at_breakpoint: None,
-            symbols: symbol_rc,
-        });
+        let state = State::Launched(debugger);
 
         seq_nr += 1;
         let mut out_messages = vec![ProtocolMessage {
@@ -320,7 +275,7 @@ impl Debugger {
         }];
 
         // Signal that we're paused if stop on entry.
-        if launch_args.stop_on_entry {
+        if launch_args.obj_launch_args.stop_on_entry {
             seq_nr += 1;
             out_messages.push(ProtocolMessage {
                 seq: self.msg_seq,
@@ -402,19 +357,25 @@ impl MessageHandler<ProtocolMessage> for Debugger {
                         .as_ref()
                         .and_then(|l| l.arguments.args.clone())
                         .unwrap_or(vec![]);
+                    let symbols = launch_extra
+                        .as_ref()
+                        .and_then(|l| l.arguments.symbols.clone())
+                        .unwrap_or("".to_string());
                     if let Some(name) = &l.name {
                         let program = launch_extra
                             .and_then(|l| l.arguments.program)
                             .unwrap_or(name.clone());
 
                         let (new_seq, new_state, out_msgs) = self.launch(LaunchArgs {
                             proto_msg: pm,
-                            name,
-                            init_args: &i,
-                            launch_request: l,
-                            program: &program,
-                            args_for_program: &args,
-                            stop_on_entry,
+                            obj_launch_args: ObjLaunchArgs {
+                                init_args: &i,
+                                name,
+                                program: &program,
+                                args_for_program: &args,
+                                symbols: &symbols,
+                                stop_on_entry,
+                            },
                         })?;
                         self.msg_seq = new_seq;
                         self.state = new_state;