Add Display for trace info (#1611)

<!-- Reference any GitHub issues resolved by this PR -->

Closes #1464 

## Introduced changes

<!-- A brief description of the changes -->

- Adds nice indented output for formatting trace info

## Checklist

<!-- Make sure all of these are complete -->

- [x] Linked relevant issue
- [x] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [x] Added changes to `CHANGELOG.md`

Author: Arcticae

crates/forge/tests/data/trace/Scarb.toml

@@ -0,0 +1,10 @@
+[package]
+name = "trace_info"
+version = "0.1.0"
+
+[dependencies]
+starknet = "2.4.0"
+snforge_std = { path = "../../../../../snforge_std" }
+
+[[target.starknet-contract]]
+sierra = true

crates/forge/tests/data/trace/src/lib.cairo

@@ -0,0 +1,44 @@
+use starknet::ContractAddress;
+
+#[derive(Drop, Serde, Clone)]
+struct RecursiveCall {
+    contract_address: ContractAddress,
+    payload: Array<RecursiveCall>
+}
+
+#[starknet::interface]
+trait RecursiveCaller<T> {
+    fn execute_calls(self: @T, calls: Array<RecursiveCall>);
+}
+
+#[starknet::contract]
+mod SimpleContract {
+    use core::array::ArrayTrait;
+    use core::traits::Into;
+    use starknet::ContractAddress;
+    use starknet::get_contract_address;
+    use super::{
+        RecursiveCaller, RecursiveCallerDispatcher, RecursiveCallerDispatcherTrait, RecursiveCall
+    };
+
+
+    #[storage]
+    struct Storage {}
+
+
+    #[abi(embed_v0)]
+    impl RecursiveCallerImpl of RecursiveCaller<ContractState> {
+        fn execute_calls(self: @ContractState, calls: Array<RecursiveCall>) {
+            let mut i = 0;
+            while i < calls
+                .len() {
+                    let serviced_call = calls.at(i);
+                    RecursiveCallerDispatcher {
+                        contract_address: serviced_call.contract_address.clone()
+                    }
+                        .execute_calls(serviced_call.payload.clone());
+                    i = i + 1;
+                }
+        }
+    }
+}

crates/forge/tests/data/trace/tests/test_trace.cairo

@@ -0,0 +1,28 @@
+use snforge_std::{declare, ContractClassTrait, PrintTrait};
+use snforge_std::trace::{get_call_trace};
+
+use trace_info::{RecursiveCallerDispatcher, RecursiveCallerDispatcherTrait, RecursiveCall};
+
+#[test]
+fn test_trace_print() {
+    let sc = declare('SimpleContract');
+
+    let contract_address_A = sc.deploy(@array![]).unwrap();
+    let contract_address_B = sc.deploy(@array![]).unwrap();
+    let contract_address_C = sc.deploy(@array![]).unwrap();
+
+    let calls = array![
+        RecursiveCall {
+            contract_address: contract_address_B,
+            payload: array![
+                RecursiveCall { contract_address: contract_address_C, payload: array![], },
+                RecursiveCall { contract_address: contract_address_C, payload: array![], }
+            ]
+        },
+        RecursiveCall { contract_address: contract_address_C, payload: array![], }
+    ];
+
+    RecursiveCallerDispatcher { contract_address: contract_address_A }.execute_calls(calls);
+
+    println!("{}", get_call_trace());
+}

crates/forge/tests/e2e/mod.rs

@@ -9,5 +9,6 @@ mod forking;
 mod fuzzing;
 mod io_operations;
 mod running;
+mod trace;
 mod trace_data;
 mod workspaces;

crates/forge/tests/e2e/trace.rs

@@ -0,0 +1,81 @@
+use crate::assert_stdout_contains;
+use crate::e2e::common::runner::{setup_package, test_runner};
+use indoc::indoc;
+
+#[test]
+fn trace_info_print() {
+    let temp = setup_package("trace");
+    let snapbox = test_runner();
+
+    let output = snapbox.current_dir(&temp).assert().success();
+
+    assert_stdout_contains!(
+        output,
+        indoc! {r"
+        [..]Compiling[..]
+        [..]Finished[..]
+
+        Collected 1 test(s) from trace_info package
+        Running 0 test(s) from src/
+        Running 1 test(s) from tests/
+        Entry point type: External
+        Selector: [..]
+        Calldata: []
+        Storage address: [..]
+        Caller address: 0
+        Call type: Call
+        Nested Calls: [
+            (
+                Entry point type: External
+                Selector: [..]
+                Calldata: [..]
+                Storage address: [..]
+                Caller address: [..]
+                Call type: Call
+                Nested Calls: [
+                    (
+                        Entry point type: External
+                        Selector: [..]
+                        Calldata: [..]
+                        Storage address: [..]
+                        Caller address: [..]
+                        Call type: Call
+                        Nested Calls: [
+                            (
+                                Entry point type: External
+                                Selector: [..]
+                                Calldata: [0]
+                                Storage address: [..]
+                                Caller address: [..]
+                                Call type: Call
+                                Nested Calls: []
+                            ),
+                            (
+                                Entry point type: External
+                                Selector: [..]
+                                Calldata: [0]
+                                Storage address: [..]
+                                Caller address: [..]
+                                Call type: Call
+                                Nested Calls: []
+                            )
+                        ]
+                    ),
+                    (
+                        Entry point type: External
+                        Selector: [..]
+                        Calldata: [0]
+                        Storage address: [..]
+                        Caller address: [..]
+                        Call type: Call
+                        Nested Calls: []
+                    )
+                ]
+            )
+        ]
+        
+        [PASS] tests::test_trace::test_trace_print (gas: [..]
+        Tests: 1 passed, 0 failed, 0 skipped, 0 ignored, 0 filtered out
+        "}
+    );
+}

snforge_std/src/trace.cairo

@@ -34,3 +34,150 @@ fn get_call_trace() -> CallTrace {
     let mut output = cheatcode::<'get_call_trace'>(array![].span());
     Serde::deserialize(ref output).unwrap()
 }
+
+use core::fmt::{Display, Formatter, Error, Debug};
+
+impl DisplayEntryPointType of Display<EntryPointType> {
+    fn fmt(self: @EntryPointType, ref f: Formatter) -> Result<(), Error> {
+        let str: ByteArray = match self {
+            EntryPointType::Constructor => "Constructor",
+            EntryPointType::External => "External",
+            EntryPointType::L1Handler => "L1 Handler",
+        };
+        f.buffer.append(@str);
+        Result::Ok(())
+    }
+}
+
+impl DisplayCallType of Display<CallType> {
+    fn fmt(self: @CallType, ref f: Formatter) -> Result<(), Error> {
+        let str: ByteArray = match self {
+            CallType::Call => "Call",
+            CallType::Delegate => "Delegate",
+        };
+        f.buffer.append(@str);
+        Result::Ok(())
+    }
+}
+
+impl DisplayCallTrace of Display<CallTrace> {
+    fn fmt(self: @CallTrace, ref f: Formatter) -> Result<(), Error> {
+        Display::fmt(@IndentedCallTrace { struct_ref: self, base_indents: 0 }, ref f).unwrap();
+        Result::Ok(())
+    }
+}
+
+#[derive(Drop)]
+struct Indented<T> {
+    struct_ref: @T,
+    base_indents: u8,
+}
+
+type IndentedEntryPoint = Indented<CallEntryPoint>;
+type IndentedCallTraceArray = Indented<Array<CallTrace>>;
+type IndentedCallTrace = Indented<CallTrace>;
+
+
+impl DisplayIndentedCallTrace of Display<Indented<CallTrace>> {
+    fn fmt(self: @Indented<CallTrace>, ref f: Formatter) -> Result<(), Error> {
+        Display::fmt(
+            @IndentedEntryPoint {
+                base_indents: *self.base_indents, struct_ref: *self.struct_ref.entry_point
+            },
+            ref f
+        )
+            .unwrap();
+        write!(f, "\n").unwrap();
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Nested Calls: [").unwrap();
+        if (*self.struct_ref.nested_calls).len() > 0 {
+            write!(f, "\n").unwrap();
+            Display::fmt(
+                @IndentedCallTraceArray {
+                    base_indents: (*self.base_indents) + 1,
+                    struct_ref: *self.struct_ref.nested_calls
+                },
+                ref f
+            )
+                .unwrap();
+            write!(f, "\n").unwrap();
+            write_indents_to_formatter(*self.base_indents, ref f);
+        }
+
+        write!(f, "]").unwrap();
+        Result::Ok(())
+    }
+}
+
+impl DisplayIndentedCallTraceArray of Display<Indented<Array<CallTrace>>> {
+    fn fmt(self: @Indented<Array<CallTrace>>, ref f: Formatter) -> Result<(), Error> {
+        let mut i: u32 = 0;
+        let trace_len = (*self.struct_ref).len();
+        while i < trace_len {
+            write_indents_to_formatter(*self.base_indents, ref f);
+            write!(f, "(\n").unwrap();
+
+            Display::fmt(
+                @IndentedCallTrace {
+                    base_indents: *self.base_indents + 1, struct_ref: (*self.struct_ref)[i]
+                },
+                ref f
+            )
+                .unwrap();
+            write!(f, "\n").unwrap();
+            write_indents_to_formatter(*self.base_indents, ref f);
+            write!(f, ")").unwrap();
+
+            i = i + 1;
+            if i != trace_len {
+                write!(f, ",\n").unwrap();
+            }
+        };
+
+        Result::Ok(())
+    }
+}
+
+impl DisplayIndentedEntryPoint of Display<Indented<CallEntryPoint>> {
+    fn fmt(self: @Indented<CallEntryPoint>, ref f: Formatter) -> Result<(), Error> {
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Entry point type: ")?;
+        Display::fmt(*self.struct_ref.entry_point_type, ref f)?;
+
+        write!(f, "\n")?;
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Selector: ")?;
+        Display::fmt(*self.struct_ref.entry_point_selector, ref f)?;
+
+        write!(f, "\n")?;
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Calldata: ")?;
+        Debug::fmt(*self.struct_ref.calldata, ref f)?;
+
+        write!(f, "\n")?;
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Storage address: ")?;
+        Debug::fmt(*self.struct_ref.contract_address, ref f)?;
+
+        write!(f, "\n")?;
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Caller address: ")?;
+        Debug::fmt(*self.struct_ref.caller_address, ref f)?;
+
+        write!(f, "\n")?;
+        write_indents_to_formatter(*self.base_indents, ref f);
+        write!(f, "Call type: ")?;
+        Display::fmt(*self.struct_ref.call_type, ref f)?;
+
+        Result::Ok(())
+    }
+}
+
+
+fn write_indents_to_formatter(indents: u8, ref f: Formatter) {
+    let mut i: u8 = 0;
+    while i < indents {
+        write!(f, "    ").unwrap();
+        i = i + 1;
+    }
+}