Debugger. #28441

mikebenfield · 2024-11-12T16:22:17Z

No description provided.

d0cd · 2024-11-15T00:13:51Z

errors/src/errors/mod.rs

@@ -110,6 +115,7 @@ impl LeoError {
            UtilError(error) => error.error_code(),
            LastErrorCode(_) => unreachable!(),
            Anyhow(_) => "SnarkVM Error".to_string(), // todo: implement error codes for snarkvm errors.
+            InterpreterHalt(_) => "Interpreter Halt".to_string(),


Should we give these a proper error code?

I'm not sure. My thought is that unlike the other error variants, InterpreterHalt doesn't necessarily represent undesired/unexpected behavior - the user may be stepping through code perfectly well expecting that an assert may trigger (or whatever).

leo/cli/commands/interpret.rs

interpreter/src/lib.rs

d0cd · 2024-11-15T00:30:53Z

interpreter/src/cursor.rs

+    integers::Integer as SvmIntegerParam,
+};
+
+type SvmAddress = SvmAddressParam<TestnetV0>;


Do we want these types parameterized over the Network?

At the moment the interpreter only works with TestnetV0. It's not clear to me whether it's important that it works with the other Networks. What do you think?

We just rolled some updates where TestnetV0 and MainnetV0 can differ in behavior depending on the block height. I could see that as being a potential case, but not much else.

interpreter/src/cursor.rs

d0cd · 2024-11-15T00:37:49Z

interpreter/src/cursor.rs

+}
+
+#[derive(Clone, Debug, Default, Eq, PartialEq, Hash)]
+pub struct Future(pub Vec<AsyncExecution>);


That way I've been thinking about Futures is that they are a single AsyncExecution, whose arguments can be other AsyncExecutions. I'm sure I'll understand as I make it further down, but is there a reason why it's a vec here?

What I have is that a Future is a sequence of AsyncExecutions, and when an async function calls await, it collects that Future's AsyncExecutions into its Future, which it will return when it finishes executing.

It's not clear to me that there is any advantage in having a tree of executions as opposed to just a sequence. Is there?

d0cd · 2024-11-15T00:39:45Z

interpreter/src/cursor.rs

+            };
+        }
+
+        if let Some(value) = match expression {


Organizational nit. Consider splitting the functional components (expression evaluation) and control flow of the REPL loop for easier maintenance.

Well, I thought I did that. Where do you consider them to be interwoven?

Ah that's my bad on the lack of clarity. I was thinking splitting them across different files.

d0cd · 2024-11-20T22:19:03Z

We should be also allow the debugger to start in a non-Leo context.

d0cd · 2024-11-20T22:24:27Z

It would be nice for the cursor for the REPL loop to show where we are currently at

> let foo: u8 = 1u8;

- reorder dependencies - typos - split into different files

This ensures the interpreter never tries to display any of these frames as if they came from a file. Also handle definitions where the left hand side is a tuple of identifiers.

Modify intro and help text.