feat(debugger): adding a way to use a prompt file for the debugger, instead of requiring the user to provide an input

Author: SuperFola

include/Ark/Constants.hpp.in

@@ -53,10 +53,10 @@ namespace Ark
     // Compiler options
     constexpr uint16_t FeatureImportSolver   = 1 << 0;
     constexpr uint16_t FeatureMacroProcessor = 1 << 1;
-    constexpr uint16_t FeatureASTOptimizer   = 1 << 2;  ///< This is disabled so that embedding ArkScript does not prune nodes from the AST ; it is active in the `arkscript` executable
+    constexpr uint16_t FeatureASTOptimizer   = 1 << 2;  ///< Disabled by default because embedding ArkScript should not prune nodes from the AST ; it is active in the `arkscript` executable
     constexpr uint16_t FeatureIROptimizer    = 1 << 3;
     constexpr uint16_t FeatureNameResolver   = 1 << 4;
-    constexpr uint16_t FeatureVMDebugger     = 1 << 5;  ///< This is disabled so that embedding ArkScript does not launch the debugger on every error when running code
+    constexpr uint16_t FeatureVMDebugger     = 1 << 5;  ///< Disabled by default because embedding ArkScript should not launch the debugger on every error when running code
 
     constexpr uint16_t FeatureDumpIR = 1 << 14;
     /// This feature should only be used in tests, to disable diagnostics generation and enable exceptions to be thrown

include/Ark/VM/Debugger.hpp

@@ -37,6 +37,13 @@ namespace Ark::internal
         std::vector<std::shared_ptr<ClosureScope>> closure_scopes;
     };
 
+    struct CompiledPrompt
+    {
+        std::vector<bytecode_t> pages;
+        std::vector<std::string> symbols;
+        std::vector<Value> constants;
+    };
+
     class Debugger
     {
     public:
@@ -48,7 +55,18 @@ namespace Ark::internal
          * @param symbols symbols table of the VM
          * @param constants constants table of the VM
          */
-        explicit Debugger(const ExecutionContext& context, const std::vector<std::filesystem::path>& libenv, const std::vector<std::string>& symbols, const std::vector<Value>& constants);
+        Debugger(const ExecutionContext& context, const std::vector<std::filesystem::path>& libenv, const std::vector<std::string>& symbols, const std::vector<Value>& constants);
+
+        /**
+         * @brief Create a new Debugger object that will use lines from a file as prompts, instead of waiting for user inputs
+         *
+         * @param libenv
+         * @param path_to_prompt_file
+         * @param os output stream
+         * @param symbols symbols table of the VM
+         * @param constants constants table of the VM
+         */
+        Debugger(const std::vector<std::filesystem::path>& libenv, const std::string& path_to_prompt_file, std::ostream& os, const std::vector<std::string>& symbols, const std::vector<Value>& constants);
 
         /**
          * @brief Save the current VM state, to get back to it once the debugger is done running
@@ -87,22 +105,27 @@ namespace Ark::internal
         std::vector<std::filesystem::path> m_libenv;
         std::vector<std::string> m_symbols;
         std::vector<Value> m_constants;
-        bool m_running;
-        bool m_quit_vm;
+        bool m_running { false };
+        bool m_quit_vm { false };
 
+        std::ostream& m_os;
+        bool m_colorize;
+        std::unique_ptr<std::istream> m_prompt_stream;
         std::string m_code;  ///< Code added while inside the debugger
-        std::size_t m_line_count = 0;
+        std::size_t m_line_count { 0 };
+
+        void showContext(const VM& vm, const ExecutionContext& context) const;
 
-        std::optional<std::string> prompt();
+        std::optional<std::string> prompt(std::size_t ip, std::size_t pp);
 
         /**
          * @brief Take care of compiling new code using the existing data tables
          *
          * @param code
          * @param start_page_at_offset offset to start the new pages at
-         * @return std::optional<std::vector<bytecode_t>> optional set of bytecode pages if compilation succeeded
+         * @return std::optional<CompiledPrompt> optional set of bytecode pages, symbols and constants if compilation succeeded
          */
-        std::optional<std::vector<bytecode_t>> compile(const std::string& code, std::size_t start_page_at_offset);
+        [[nodiscard]] std::optional<CompiledPrompt> compile(const std::string& code, std::size_t start_page_at_offset) const;
     };
 }
 

include/Ark/VM/VM.hpp

@@ -151,6 +151,14 @@ namespace Ark
          */
         [[nodiscard]] bool forceReloadPlugins() const;
 
+        /**
+         * @brief Configure the debugger to use a prompt file instead of asking the user for an input
+         *
+         * @param path path to prompt file (one prompt per line)
+         * @param os output stream
+         */
+        void usePromptFileForDebugger(const std::string& path, std::ostream& os = std::cout);
+
         /**
          * @brief Throw a VM error message
          *

src/arkreactor/Compiler/Welder.cpp

@@ -55,7 +55,7 @@ namespace Ark
         m_root_file = std::filesystem::current_path();  // No filename given, take the current working directory
 
         for (const std::string& sym : symbols)
-            m_name_resolver.addDefinedSymbol(sym, /* is_mutable= */ false);
+            m_name_resolver.addDefinedSymbol(sym, /* is_mutable= */ true);
         return computeAST(ARK_NO_NAME_FILE, code);
     }
 

src/arkreactor/VM/Debugger.cpp

@@ -2,6 +2,7 @@
 
 #include <fmt/core.h>
 #include <fmt/color.h>
+#include <fmt/ostream.h>
 
 #include <Ark/State.hpp>
 #include <Ark/VM/VM.hpp>
@@ -13,11 +14,17 @@
 namespace Ark::internal
 {
     Debugger::Debugger(const ExecutionContext& context, const std::vector<std::filesystem::path>& libenv, const std::vector<std::string>& symbols, const std::vector<Value>& constants) :
-        m_libenv(libenv), m_symbols(symbols), m_constants(constants), m_running(false), m_quit_vm(false)
+        m_libenv(libenv), m_symbols(symbols), m_constants(constants), m_os(std::cout), m_colorize(true)
     {
         saveState(context);
     }
 
+    Debugger::Debugger(const std::vector<std::filesystem::path>& libenv, const std::string& path_to_prompt_file, std::ostream& os, const std::vector<std::string>& symbols, const std::vector<Value>& constants) :
+        m_libenv(libenv), m_symbols(symbols), m_constants(constants), m_os(os), m_colorize(false)
+    {
+        m_prompt_stream = std::make_unique<std::ifstream>(path_to_prompt_file);
+    }
+
     void Debugger::saveState(const ExecutionContext& context)
     {
         m_states.emplace_back(
@@ -45,72 +52,89 @@ namespace Ark::internal
 
     void Debugger::run(VM& vm, ExecutionContext& context)
     {
+        showContext(vm, context);
+
         m_running = true;
         const bool is_vm_running = vm.m_running;
-
-        // show the line where the breakpoint hit
-        const auto maybe_source_loc = vm.findSourceLocation(context.ip, context.pp);
-        if (maybe_source_loc)
-        {
-            const auto filename = vm.m_state.m_filenames[maybe_source_loc->filename_id];
-
-            if (Utils::fileExists(filename))
-            {
-                fmt::println("");
-                Diagnostics::makeContext(
-                    Diagnostics::ErrorLocation {
-                        .filename = filename,
-                        .start = FilePos { .line = maybe_source_loc->line, .column = 0 },
-                        .end = std::nullopt },
-                    std::cout,
-                    /* maybe_context= */ std::nullopt,
-                    /* colorize= */ true);
-                fmt::println("");
-            }
-        }
+        const std::size_t ip_at_breakpoint = context.ip,
+                          pp_at_breakpoint = context.pp;
+        // create dedicated scope, so that we won't be overwriting existing variables
+        context.locals.emplace_back(context.scopes_storage.data(), context.locals.back().storageEnd());
+        std::size_t last_ip = 0;
 
         while (true)
         {
-            std::optional<std::string> maybe_input = prompt();
+            std::optional<std::string> maybe_input = prompt(ip_at_breakpoint, pp_at_breakpoint);
 
             if (maybe_input)
             {
                 const std::string& line = maybe_input.value();
 
-                if (const auto pages = compile(m_code + line, vm.m_state.m_pages.size()); pages.has_value())
+                if (const auto compiled = compile(m_code + line, vm.m_state.m_pages.size()); compiled.has_value())
                 {
-                    context.ip = 0;
+                    context.ip = last_ip;
                     context.pp = vm.m_state.m_pages.size();
-                    // create dedicated scope, so that we won't be overwriting existing variables
-                    context.locals.emplace_back(context.scopes_storage.data(), context.locals.back().storageEnd());
 
-                    vm.m_state.extendBytecode(pages.value(), m_symbols, m_constants);
+                    vm.m_state.extendBytecode(compiled->pages, compiled->symbols, compiled->constants);
 
                     if (vm.safeRun(context) == 0)
                     {
                         // executing code worked
-                        m_code += line;
+                        m_code += line + "\n";
+                        // place ip to end of bytecode instruction (HALT)
+                        last_ip = context.ip - 4;
 
                         const Value* maybe_value = vm.peekAndResolveAsPtr(context);
                         if (maybe_value != nullptr && maybe_value->valueType() != ValueType::Undefined && maybe_value->valueType() != ValueType::InstPtr)
-                            fmt::println("{}", fmt::styled(maybe_value->toString(vm), fmt::fg(fmt::color::chocolate)));
+                            fmt::println(
+                                m_os,
+                                "{}",
+                                fmt::styled(
+                                    maybe_value->toString(vm),
+                                    m_colorize ? fmt::fg(fmt::color::chocolate) : fmt::text_style()));
                     }
-
-                    context.locals.pop_back();
                 }
             }
             else
                 break;
         }
 
-        m_running = false;
+        context.locals.pop_back();
+
         // we do not want to retain code from the past executions
         m_code.clear();
+        m_line_count = 0;
+
         // we hit a HALT instruction that set 'running' to false, ignore that if we were still running!
         vm.m_running = is_vm_running;
+        m_running = false;
     }
 
-    std::optional<std::string> Debugger::prompt()
+    void Debugger::showContext(const VM& vm, const ExecutionContext& context) const
+    {
+        // show the line where the breakpoint hit
+        const auto maybe_source_loc = vm.findSourceLocation(context.ip, context.pp);
+        if (maybe_source_loc)
+        {
+            const auto filename = vm.m_state.m_filenames[maybe_source_loc->filename_id];
+
+            if (Utils::fileExists(filename))
+            {
+                fmt::println(m_os, "");
+                Diagnostics::makeContext(
+                    Diagnostics::ErrorLocation {
+                        .filename = filename,
+                        .start = FilePos { .line = maybe_source_loc->line, .column = 0 },
+                        .end = std::nullopt },
+                    m_os,
+                    /* maybe_context= */ std::nullopt,
+                    /* colorize= */ m_colorize);
+                fmt::println(m_os, "");
+            }
+        }
+    }
+
+    std::optional<std::string> Debugger::prompt(const std::size_t ip, const std::size_t pp)
     {
         std::string code;
         long open_parens = 0;
@@ -119,29 +143,42 @@ namespace Ark::internal
         while (true)
         {
             const bool unfinished_block = open_parens != 0 || open_braces != 0;
-            fmt::print("dbg:{:0>3}{} ", m_line_count, unfinished_block ? ":" : ">");
+            fmt::print(
+                m_os,
+                "dbg[{},{}]:{:0>3}{} ",
+                fmt::format("pp:{}", fmt::styled(pp, m_colorize ? fmt::fg(fmt::color::green) : fmt::text_style())),
+                fmt::format("ip:{}", fmt::styled(ip, m_colorize ? fmt::fg(fmt::color::cyan) : fmt::text_style())),
+                m_line_count,
+                unfinished_block ? ":" : ">");
+
             std::string line;
-            std::getline(std::cin, line);
+            if (m_prompt_stream)
+            {
+                std::getline(*m_prompt_stream, line);
+                fmt::println(m_os, "{}", line);  // because nothing is printed otherwise, and prompts get printed on the same line
+            }
+            else
+                std::getline(std::cin, line);
 
             Utils::trimWhitespace(line);
 
             if (line == "c" || line == "continue" || line.empty())
             {
-                fmt::println("dbg: continue");
+                fmt::println(m_os, "dbg: continue");
                 return std::nullopt;
             }
             else if (line == "q" || line == "quit")
             {
-                fmt::println("dbg: stop");
+                fmt::println(m_os, "dbg: stop");
                 m_quit_vm = true;
                 return std::nullopt;
             }
             else if (line == "help")
             {
-                fmt::println("Available commands:");
-                fmt::println("  help -- display this message");
-                fmt::println("  c, continue -- resume execution");
-                fmt::println("  q, quit -- quit the debugger, stopping the script execution");
+                fmt::println(m_os, "Available commands:");
+                fmt::println(m_os, "  help -- display this message");
+                fmt::println(m_os, "  c, continue -- resume execution");
+                fmt::println(m_os, "  q, quit -- quit the debugger, stopping the script execution");
             }
             else
             {
@@ -159,7 +196,7 @@ namespace Ark::internal
         return code;
     }
 
-    std::optional<std::vector<bytecode_t>> Debugger::compile(const std::string& code, const std::size_t start_page_at_offset)
+    std::optional<CompiledPrompt> Debugger::compile(const std::string& code, const std::size_t start_page_at_offset) const
     {
         Welder welder(0, m_libenv, DefaultFeatures);
         if (!welder.computeASTFromStringWithKnownSymbols(code, m_symbols))
@@ -175,9 +212,6 @@ namespace Ark::internal
         const auto inst_locs = bcr.instLocations(files);
         const auto [pages, _] = bcr.code(inst_locs);
 
-        m_symbols = syms.symbols;
-        m_constants = vals.values;
-
-        return pages;
+        return std::optional(CompiledPrompt(pages, syms.symbols, vals.values));
     }
 }

src/arkreactor/VM/VM.cpp

@@ -510,6 +510,11 @@ namespace Ark
         }
     }
 
+    void VM::usePromptFileForDebugger(const std::string& path, std::ostream& os)
+    {
+        m_debugger = std::make_unique<Debugger>(m_state.m_libenv, path, os, m_state.m_symbols, m_state.m_constants);
+    }
+
     void VM::throwVMError(ErrorKind kind, const std::string& message)
     {
         throw std::runtime_error(std::string(errorKinds[static_cast<std::size_t>(kind)]) + ": " + message + "\n");

tests/unittests/Suites/DebuggerSuite.cpp

@@ -0,0 +1,52 @@
+#include <boost/ut.hpp>
+
+#include <fmt/ostream.h>
+
+#include <Ark/Ark.hpp>
+#include <TestsHelper.hpp>
+
+using namespace boost;
+
+ut::suite<"Debugger"> debugger_suite = [] {
+    using namespace ut;
+
+    constexpr uint16_t features = Ark::DefaultFeatures | Ark::FeatureVMDebugger;
+
+    iterTestFiles(
+        "DebuggerSuite",
+        [](TestData&& data) {
+            std::stringstream os;
+            Ark::State state({ lib_path });
+
+            // cppcheck-suppress constParameterReference
+            state.loadFunction("prn", [&os](std::vector<Ark::Value>& args, Ark::VM* vm) -> Ark::Value {
+                for (const auto& value : args)
+                    fmt::print(os, "{}", value.toString(*vm));
+                fmt::println(os, "");
+                return Ark::Nil;
+            });
+
+            should("compile without error for " + data.stem) = [&] {
+                expect(mut(state).doFile(data.path, features));
+            };
+
+            should("launch the debugger and compute expressions for " + data.stem) = [&] {
+                std::filesystem::path prompt_path(data.path);
+                prompt_path.replace_extension("prompt");
+
+                try
+                {
+                    Ark::VM vm(state);
+                    vm.usePromptFileForDebugger(prompt_path.generic_string(), os);
+                    vm.run(/* fail_with_exception= */ true);
+
+                    const std::string output = sanitizeOutput(os.str());
+                    expectOrDiff(data.expected, output);
+                }
+                catch (const std::exception&)
+                {
+                    expect(false);
+                }
+            };
+        });
+};