The beginnings of a stack trace

[jjtolton]

:- use_module(library(debug)).
:- use_module(library(reif)).
:- use_module(library(dif)).
:- use_module(library(clpz)).
:- use_module(library(charsio)).
:- use_module(library(assoc)).
:- use_module(library(iso_ext)).
:- use_module(library(lists)).
:- use_module(library(format)).

user:term_expansion((:- error_stack), (:- initialization(true))) :-
        bb_put(error_stack, [start]),
        bb_put(traced_stack, t),
        bb_put(previous, start).

user:print_stack_trace([]).
user:print_stack_trace([start|Stack]) :-
        user:print_stack_trace(Stack), !.
user:print_stack_trace([G|Stack]) :-
        G=(_,_,_,S),
        if_((   S=do_throw_error(_, _)
            ;   S=user:do_throw_error(_,_)),
            true,
            (   format("[-] ~q~n", [S]),
                user:print_stack_trace(Stack)
            )
           ).

user:print_error_context(context(term_position(position_and_lines_read(Position, Line)),
                                 module(Module),
                                 file(File),
                                 source(Source),
                                 _)
                        ) :-
        format("Terminating Error:~n~n", []),
        format("[+] Position: ~q~n", [Position]),
        format("[+] Line:     ~q~n", [Line]),
        format("[+] Module:   ~q~n", [Module]),
        format("[+] Source:   ~q~n", [Source]),
        format("[+] File:     ~q~n~n~nBegin Trace:~n~n", [File]).
        
user:do_throw_error(Stack, error(Error, Context)) :-
        user:print_error_context(Context),
        user:print_stack_trace(Stack),
        error(Error, Context).

user:goal_expansion(throw_error(Error), user:do_throw_error(Stack, error(Error, ErrorData))) :-
        bb_get(error_stack, _),
        (   prolog_load_context(term_position, TermPosition) 
        ;   TermPosition=false
        ),
        (   prolog_load_context(module, Module)
        ;   Module=false
        ),
        (   prolog_load_context(file, File)
        ;   File=false
        ),
        (   prolog_load_context(source, Source)
        ;   Source=false
        ),
        bb_get(error_stack, Stack),
        ErrorData=context(term_position(TermPosition),
                          module(Module),
                          file(File),
                          source(Source),
                          stack(Stack)
                         ).
                   
        
user:goal_expansion(G, G) :-
        bb_get(error_stack, Stack), 
        bb_get(previous, X),
        prolog_load_context(module, Module),
        prolog_load_context(term_position, position_and_lines_read(Pos, Line)),
        dif(G, X),
        bb_b_put(previous, G),
        append(Stack, [(position(Pos), line(Line), module(Module), G)], Stack1), 
        bb_b_put(error_stack, Stack1).
        

:- module(errordemo, []).
:- error_stack.
        

foo :- bar.
bar :- baz.
baz :- qux.
qux :- throw_error(whoa).


/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   ?- errordemo:foo.
   %@ Terminating Error:
   %@ 
   %@ [+] Position: 2920
   %@ [+] Line:     88
   %@ [+] Module:   errordemo
   %@ [+] Source:   '/tmp/ediprolognrdDDw'
   %@ [+] File:     ediprolognrdDDw
   %@ 
   %@ 
   %@ Begin Trace:
   %@ 
   %@ [-] bar
   %@ [-] baz
   %@ [-] qux
   %@    error(whoa,context(term_position(position_and_lines_read(2920,88)),module(errordemo),file(ediprolognrdDDw),source('/tmp/ediprolognrdDDw'),stack([start,(position(2870),line(85),module(errordemo),bar),(position(2882),line(86),module(errordemo),baz),(position(2894),line(87),module(errordemo),qux),(position(2920),line(88),module(errordemo),user:do_throw_error([start,(position(2870),line(85),module(errordemo),bar),(position(2882),line(86),module(errordemo),baz),(position(2894),line(87),module(errordemo),qux)],error(whoa,context(term_position(position_and_lines_read(2920,88)),module(errordemo),file(ediprolognrdDDw),source('/tmp/ediprolognrdDDw'),stack([start,(position(2870),line(85),module(errordemo),bar),(position(2882),line(86),module(errordemo),baz),(position(2894),line(87),module(errordemo),qux)]))))),(position(2920),line(88),module(errordemo),do_throw_error([start,(position(2870),line(85),module(errordemo),bar),(position(2882),line(86),module(errordemo),baz),(position(2894),line(87),module(errordemo),qux)],error(whoa,context(term_position(position_and_lines_read(2920,88)),module(errordemo),file(ediprolognrdDDw),source('/tmp/ediprolognrdDDw'),stack([start,(position(2870),line(85),module(errordemo),bar),(position(2882),line(86),module(errordemo),baz),(position(2894),line(87),module(errordemo),qux)])))))]))).
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */

[jjtolton]

One of the cute dumb things I figured out is you can "hook" a goal without modifying it if you statefully track which goals you were just looking at :P

It is sad how long that took me to figure out today 😭

user:goal_expansion(G, G) :-
        bb_get(error_stack, Stack), 
        bb_get(previous, X),  
        prolog_load_context(module, Module),
        prolog_load_context(term_position, position_and_lines_read(Pos, Line)),
        dif(G, X), %% <--- ensure we aren't infinitely expanding the same goal
        bb_b_put(previous, G),
        append(Stack, [(position(Pos), line(Line), module(Module), G)], Stack1), 
        bb_b_put(error_stack, Stack1).

[hurufu]

Very interesting, will it work as a module: :- use_module(stack_trace).?

[jjtolton]

Sure does :) Will upload library version w/few more
features soon.

[jjtolton]

Actually I am having a bit of trouble making it into a module, I need to mess around with it a little more to figure out how to properly "export" the term/goal expansions. I'll keep you posted.

[triska]

This approach is indeed extremely interesting!

Related to tracing, I once wrote Emacs definitions that let you interactively step through Prolog code, by highlighting the goals that are being executed:

https://www.metalevel.at/etrace/

Personally, I do not recommend such a "stepping through" the computation, because it detracts us from implementing and applying better approaches. Nevertheless, I consider it interesting to think about which features a Prolog system must provide to make this approach possible. It would be great to implement this approach more portably, so that it can be used for instance with Scryer Prolog too, and your idea of using the existing expansion mechanisms together with a few predicates that let us locate the positions of terms we need to know could be a very promising and conceptually elegant solution for this!

[jjtolton]

First of all this will be cool just to study! Secondly, after my experience with SICStus Spider IDE, I was actually quite surprised to find that stepping thru Prolog code was indeed of limited value! However, I did find when working on computationally hard problems that it is easy to find yourself in an unexpected program state, and sometimes an error report in isolation, especially when you are surprised to find the error occurs in the first place, such as error(impossible, "This should never happen") happens, it can be very valuable to see the goals that occurred to get there.

Now that may be an admission of my own weakness as a programmer, but if this technique will help turn a debugging session that would normally take me 3-4 hours into 5 minutes, I'm willing to accept the blow to my ego :)

[triska]

Yes absolutely, seeing more context (ideally as part of the exception term) when exceptions arise is very interesting!

[UWN]

@jjtolton, consider to use error(system_error, "You message") in stead.

[jjtolton]

I was on a really silly mission to get a stack trace involved, but my understanding of goal_expansion/2 and term_expansion/2. I didn't realize that goal_expansion/2 also runs at consult time, which made the stack traces completely incorrect. I never found a way around that so I moved on to other techniques.

@jjtolton, consider to use error(system_error, "You message") in stead.

And yes I would never use such silly errors normally :P

[jjtolton]

I'm starting to think this is a fools errand. Full post-mortem will have to wait, though.

[hurufu]

I have another comment about your approach. It is hard to control if your particular goal expansion will be performed before or after other possible expansions. That means that if someone else also does some sort of term/goal manipulation, then stack trace will be unreliable. Maybe it will be possible to design an elegant goal expansion mechanism that can guarantee order of transformations...

[jjtolton]

yeah that's exactly what I was running into, decided to abandon the approach, not worth it right now

[hurufu]

The simplest possible stack trace tool can be implemented like this:

:- use_module(library(format)).
rethrow(G) :-
    catch(G, E, (portray_clause(G), throw(E))).

user:goal_expansion(G, rethrow(G)) :-
    G \= rethrow(_).

It doesn't have line numbers and file names, but I just wanted to show the concept. It also has some problems, that's why I think that if you really need a robust debugger it has to be a meta-interpreter.

[jjtolton]

Yes, I think interleaving an interpreter along with goal/term expansion might be necessary to pull it off. However, I actually think the expansion system doesn't provide enough information to do the job cleanly.

For instance, there is no way that I know of to tell if you are already in an expansion context (so as to not double expand a goal that is already expanded) and there is no way to know if you are in a consult or top-level context.

[jjtolton]

There is actually some very cool examples of that in tabling/wrapper.