refactor: trying to go non-heap

sillydan1 · sillydan1 · commit e7de09f355c0 · 2024-07-28T11:51:04.000+02:00
diff --git a/src/cli/detcheck/main.cpp b/src/cli/detcheck/main.cpp
@@ -24,8 +24,8 @@
 #include <plugin_system/plugin_system.h>
 #include <timer>
 
-auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> std::unique_ptr<aaltitoad::ntta_t>;
-void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file);
+auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> aaltitoad::ntta_t;
+void find_deadlocks(const aaltitoad::ntta_t& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file);
 
 int main(int argc, char** argv) {
     bool show_help = false;
@@ -97,7 +97,7 @@ int main(int argc, char** argv) {
 
     auto automata = get_ntta(plugin_dirs, ignore, parser, input);
     if(list_instances) {
-        for(auto& c: automata->components)
+        for(auto& c: automata.components)
             std::cout << c.first << " ";
         std::cout << std::endl;
         return 0;
@@ -108,7 +108,7 @@ int main(int argc, char** argv) {
     return 0;
 }
 
-auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> std::unique_ptr<aaltitoad::ntta_t> {
+auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std::string>& ignore_list, const std::string& parser, const std::vector<std::string>& input) -> aaltitoad::ntta_t {
     /// Load plugins
     auto available_plugins = aaltitoad::plugins::load(plugin_dirs);
 
@@ -124,9 +124,8 @@ auto get_ntta(const std::vector<std::string>& plugin_dirs, const std::vector<std
     aaltitoad::warnings::print_warnings(parse_result);
     if(!parse_result.has_value())
         throw std::logic_error("compilation failed");
-    auto automata = std::move(parse_result.value().ntta);
     spdlog::trace("model parsing took {0}ms", t.milliseconds_elapsed());
-    return automata;
+    return parse_result.value().ntta;
 }
 
 auto get_mentioned_symbols(const expr::syntax_tree_t& expression, const expr::symbol_table_t& symbols) -> expr::symbol_table_t {
@@ -149,9 +148,9 @@ auto get_mentioned_symbols(const expr::syntax_tree_t& expression, const expr::sy
     return mentioned;
 }
 
-void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file) {
+void find_deadlocks(const aaltitoad::ntta_t& ntta, const std::vector<std::string>& conditions, const std::optional<std::string>& condition_file, const std::vector<std::string> knowns, const std::optional<std::string>& known_file, const std::vector<std::string>& instance, const std::optional<std::string>& instance_file) {
     ya::timer<unsigned int> t{};
-    aaltitoad::expression_driver c{ntta->symbols, ntta->external_symbols};
+    aaltitoad::expression_driver c{ntta.symbols, ntta.external_symbols};
     std::vector<expr::syntax_tree_t> extra_conditions{};
     for(auto& condition : conditions) {
         auto result = c.parse(condition);
@@ -196,9 +195,9 @@ void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::v
     }
     for(auto& instance: instances) {
         spdlog::trace("looking for '{0}' in components", instance);
-        for(auto& location: ntta->components.at(instance).graph->nodes)
+        for(auto& location: ntta.components.at(instance).graph->nodes)
             for(auto& edge: location.second.outgoing_edges)
-                unknown_symbols += get_mentioned_symbols(edge->second.data.guard, ntta->symbols + ntta->external_symbols);
+                unknown_symbols += get_mentioned_symbols(edge->second.data.guard, ntta.symbols + ntta.external_symbols);
     }
     spdlog::trace("finding {0} mentioned symbols in {1} tta instances took {2}ms", unknown_symbols.size(), instances.size(), t.milliseconds_elapsed());
 
@@ -209,7 +208,7 @@ void find_deadlocks(const std::unique_ptr<aaltitoad::ntta_t>& ntta, const std::v
     aaltitoad::expression_driver d{known_symbols, unknown_symbols};
     for(auto& instance : instances) {
         spdlog::trace("looking for '{0}' in components", instance);
-        for(auto& location : ntta->components.at(instance).graph->nodes) {
+        for(auto& location : ntta.components.at(instance).graph->nodes) {
             t.start();
             if(location.second.outgoing_edges.empty())
                 continue;
diff --git a/src/cli/simulator/main.cpp b/src/cli/simulator/main.cpp
@@ -126,9 +126,9 @@ int main(int argc, char** argv) {
 
     /// Inject tockers - CLI Format: "name(argument)"
     for(auto& arg : tockers) {
-        auto tocker = instantiate_tocker(arg, available_plugins, *automata);
+        auto tocker = instantiate_tocker(arg, available_plugins, automata);
         if(tocker.has_value())
-            automata->tockers.emplace_back(std::move(tocker.value()));
+            automata.tockers.emplace_back(std::move(tocker.value()));
     }
 
     /// Run
@@ -141,15 +141,15 @@ int main(int argc, char** argv) {
         for (; i < ticks || ticks < 0; i++) {
             if(spdlog::get_level() <= spdlog::level::trace) {
                 std::stringstream ss{};
-                ss << "state:\n" << *automata;
+                ss << "state:\n" << automata;
                 spdlog::trace(ss.str());
             }
-            auto tock_changes = automata->tock();
+            auto tock_changes = automata.tock();
             if(!tock_changes.empty())
-                automata->apply(tock_changes[0]);
-            auto tick_changes = automata->tick();
+                automata.apply(tock_changes[0]);
+            auto tick_changes = automata.tick();
             if(!tick_changes.empty())
-                automata->apply(tick_changes[0]);
+                automata.apply(tick_changes[0]);
         }
 #ifdef NDEBUG
     } catch (std::exception& e) {
diff --git a/src/cli/verifier/main.cpp b/src/cli/verifier/main.cpp
@@ -139,13 +139,13 @@ int main(int argc, char** argv) {
             return 1;
         }
 
-        auto n = std::move(parse_result.value().ntta);
-        trace_log_ntta(*n);
+        auto n = parse_result.value().ntta;
+        trace_log_ntta(n);
         spdlog::debug("model parsing took {0}ms", t.milliseconds_elapsed());
 
         t.start();
         std::vector<ctl::syntax_tree_t> queries{};
-        aaltitoad::ctl_interpreter ctl_compiler{n->symbols, n->external_symbols};
+        aaltitoad::ctl_interpreter ctl_compiler{n.symbols, n.external_symbols};
         for(auto& q : query) {
             spdlog::trace("compiling query '{0}'", q);
             auto qq = ctl_compiler.compile(q);
@@ -155,19 +155,19 @@ int main(int argc, char** argv) {
         }
         for(auto& f : query_files) {
             spdlog::trace("loading queries in file {0}", f);
-            auto json_queries = aaltitoad::load_query_json_file(f, {n->symbols, n->external_symbols});
+            auto json_queries = aaltitoad::load_query_json_file(f, {n.symbols, n.external_symbols});
             queries.insert(queries.end(), json_queries.begin(), json_queries.end());
         }
         spdlog::debug("query parsing took {0}ms", t.milliseconds_elapsed());
 
         auto strategy = magic_enum::enum_cast<aaltitoad::pick_strategy>(pick_strategy).value_or(aaltitoad::pick_strategy::first);
         spdlog::debug("using pick strategy '{0}'", magic_enum::enum_name(strategy));
 
-        n->add_tocker(std::make_unique<aaltitoad::interesting_tocker>());
+        n.add_tocker(std::make_unique<aaltitoad::interesting_tocker>());
         spdlog::trace("starting reachability search for {0} queries", queries.size());
         t.start();
         aaltitoad::forward_reachability_searcher frs{strategy};
-        auto results = frs.is_reachable(*n, queries);
+        auto results = frs.is_reachable(n, queries);
         spdlog::info("reachability search took {0}ms", t.milliseconds_elapsed());
 
         // open the results file (std::cout by default)
diff --git a/src/parser/hawk/compiler.cpp b/src/parser/hawk/compiler.cpp
@@ -12,17 +12,17 @@ namespace aaltitoad::hawk {
     }
 
     compiler::compiler(
-            std::unique_ptr<scanner>&& _scanner,
-            std::unique_ptr<parser>&& _parser,
-            std::unique_ptr<semantic_analyzer>&& _analyzer,
-            std::unique_ptr<optimizer>&& _optimizer,
-            std::unique_ptr<generator>&& _generator)
+            scanner& _scanner,
+            parser& _parser,
+            semantic_analyzer& _analyzer,
+            optimizer& _optimizer,
+            generator& _generator)
         : 
-            _scanner{std::move(_scanner)},
-            _parser{std::move(_parser)},
-            _analyzer{std::move(_analyzer)},
-            _optimizer{std::move(_optimizer)},
-            _generator{std::move(_generator)},
+            _scanner{_scanner},
+            _parser{_parser},
+            _analyzer{_analyzer},
+            _optimizer{_optimizer},
+            _generator{_generator},
             symbols{},
             _diagnostic_factory{} {
     }
@@ -36,18 +36,18 @@ namespace aaltitoad::hawk {
     }
 
     auto compiler::compile(const std::vector<std::string>& paths, const std::vector<std::string>& ignore_list) -> std::expected<ok, error_t> {
-        auto stream = _scanner->scan(*this, paths, ignore_list);
+        auto stream = _scanner.scan(*this, paths, ignore_list);
         if(!stream)
             return std::unexpected{stream.error()};
-        auto ast = _parser->parse(*this, stream.value());
+        auto ast = _parser.parse(*this, stream.value());
         if(!ast)
             return std::unexpected{ast.error()};
-        auto dast_r = _analyzer->analyze(*this, ast.value());
+        auto dast_r = _analyzer.analyze(*this, ast.value());
         if(!dast_r)
             return std::unexpected{dast_r.error()};
         auto dast = dast_r.value();
-        _optimizer->optimize(*this, dast);
-        auto ntta = _generator->generate(*this, dast);
+        _optimizer.optimize(*this, dast);
+        auto ntta = _generator.generate(*this, dast);
         if(!ntta)
             return std::unexpected(ntta.error());
         return ok{
@@ -67,4 +67,8 @@ namespace aaltitoad::hawk {
     error_t::error_t() : diagnostics{} {}
 
     error_t::error_t(const std::vector<Diagnostic>& diagnostics) : diagnostics{diagnostics} {}
+
+    void nothing_optimizer::optimize(compiler& ctx, parser::ok& ast) const {
+        
+    }
 }
diff --git a/src/parser/hawk/compiler.h b/src/parser/hawk/compiler.h
@@ -58,6 +58,12 @@ namespace aaltitoad::hawk {
         virtual void optimize(compiler& ctx, parser::ok& ast) const = 0;
     };
 
+    class nothing_optimizer : public optimizer {
+    public:
+        ~nothing_optimizer() override = default;
+        void optimize(compiler& ctx, parser::ok& ast) const override;
+    };
+
     struct generator {
         generator() = default;
         virtual ~generator() = default;
@@ -71,24 +77,20 @@ namespace aaltitoad::hawk {
             std::vector<Diagnostic> diagnostics;
         };
 
-        compiler(
-                std::unique_ptr<scanner>&& scanner,
-                std::unique_ptr<parser>&& parser,
-                std::unique_ptr<semantic_analyzer>&& analyzer,
-                std::unique_ptr<optimizer>&& optimizer,
-                std::unique_ptr<generator>&& generator);
+        compiler(scanner& scanner);
+        compiler(scanner& scanner, parser& parser, semantic_analyzer& analyzer, optimizer& optimizer, generator& generator);
         void add_symbols(const expr::symbol_table_t& symbols);
         void clear_symbols();
         auto get_diagnostic_factory() -> diagnostic_factory&;
         auto diag(const diagnostic& d) -> Diagnostic;
         auto compile(const std::vector<std::string>& paths, const std::vector<std::string>& ignore_list) -> std::expected<ok, error_t>;
 
     private:
-        std::unique_ptr<scanner> _scanner;
-        std::unique_ptr<parser> _parser;
-        std::unique_ptr<semantic_analyzer> _analyzer;
-        std::unique_ptr<optimizer> _optimizer;
-        std::unique_ptr<generator> _generator;
+        scanner& _scanner;
+        parser& _parser;
+        semantic_analyzer& _analyzer;
+        optimizer& _optimizer;
+        generator& _generator;
         expr::symbol_table_t symbols;
         diagnostic_factory _diagnostic_factory;
     };
diff --git a/src/parser/hawk/huppaal/parser.cpp b/src/parser/hawk/huppaal/parser.cpp
@@ -69,19 +69,21 @@ namespace aaltitoad::hawk::huppaal {
         return std::unexpected(error_t({ctx.diag(not_implemented_yet())}));
     }
 
-    parser::parser() : compiler{} {
-        
-    }
-
     auto parser::parse_files(const std::vector<std::string>& files, const std::vector<std::string>& ignore_patterns) -> plugin::parse_result {
-        auto compile_result = compiler->compile(files, ignore_patterns);
+        auto compiler = create_compiler();
+        auto compile_result = compiler.compile(files, ignore_patterns);
         if(!compile_result.has_value())
             return std::unexpected(plugin::parse_error{compile_result.error().diagnostics});
         return plugin::parse_ok{compile_result.value().ntta, compile_result.value().diagnostics};
     }
 
     auto parser::parse_model(const Buffer& buffer) -> plugin::parse_result {
-        return std::unexpected(plugin::parse_error({compiler->diag(not_implemented_yet())}));
+        auto compiler = create_compiler();
+        return std::unexpected(plugin::parse_error{std::vector<Diagnostic>{compiler.diag(not_implemented_yet())}});
+    }
+
+    auto parser::create_compiler() -> compiler {
+        return compiler{_scanner, _parser, _semantic_analyzer, _optimizer, _generator};
     }
 }
 
diff --git a/src/parser/hawk/huppaal/parser.h b/src/parser/hawk/huppaal/parser.h
@@ -24,7 +24,7 @@
 namespace aaltitoad::hawk::huppaal {
     auto create_parser() -> plugin::parser*;
 
-    class huppaal_scanner : public aaltitoad::hawk::scanner{
+    class huppaal_scanner : public aaltitoad::hawk::scanner {
     public:
         ~huppaal_scanner() override = default;
         auto scan(compiler& ctx,
@@ -41,14 +41,31 @@ namespace aaltitoad::hawk::huppaal {
         auto parse(compiler& ctx, const scanner::ok& stream) const noexcept -> std::expected<parser::ok, error_t> override;
     };
 
+    class huppaal_semantic_analyzer : public aaltitoad::hawk::semantic_analyzer {
+    public:
+        ~huppaal_semantic_analyzer() override = default;
+        auto analyze(compiler& ctx, const parser::ok& ast) const noexcept -> std::expected<parser::ok, error_t> override;
+    };
+
+    class huppaal_generator : public aaltitoad::hawk::generator {
+    public:
+        ~huppaal_generator() override = default;
+        auto generate(compiler& ctx, const parser::ok& ast) const noexcept -> std::expected<ntta_t, error_t> override;
+    };
+
     class parser : public plugin::parser {
     public:
-        parser();
         ~parser() override = default;
         auto parse_files(const std::vector<std::string>& files, const std::vector<std::string>& ignore_patterns) -> plugin::parse_result override;
         auto parse_model(const Buffer& buffer) -> plugin::parse_result override;
     private:
-        std::unique_ptr<compiler> compiler;
+        auto create_compiler() -> compiler;
+
+        huppaal_scanner _scanner;
+        huppaal_parser _parser;
+        huppaal_semantic_analyzer _semantic_analyzer;
+        nothing_optimizer _optimizer;
+        huppaal_generator _generator;
     };
 }
 
diff --git a/src/parser/hawk/scoped_template_builder/scoped_template_builder.cpp b/src/parser/hawk/scoped_template_builder/scoped_template_builder.cpp
@@ -256,7 +256,7 @@ namespace aaltitoad::hawk {
         builder.add_symbols(internal_symbols);
         builder.add_external_symbols(external_symbols);
         return plugin::parse_ok{
-            .ntta=std::unique_ptr<ntta_t>{builder.build_heap()},
+            .ntta=builder.build(),
             .diagnostics=diagnostics
         };
     }
diff --git a/src/plugin_system/parser.h b/src/plugin_system/parser.h
@@ -2,7 +2,6 @@
 #define AALTITOAD_PARSER_H
 #include "lsp.pb.h"
 #include "ntta/tta.h"
-#include <memory>
 #include <expected>
 
 namespace aaltitoad::plugin {
diff --git a/test/verification/parser_tests.cpp b/test/verification/parser_tests.cpp
@@ -34,9 +34,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {
             REQUIRE(parse_result.has_value());
             CHECK(parse_result.value().diagnostics.size() == 1); // TODO: The success state should not result in diagnostics
             auto n = std::move(parse_result.value().ntta);
-            std::cout << *n << std::endl;
+            std::cout << n << std::endl;
             THEN("three TTAs are constructed (Main, fischer1, and fischer2)") {
-                REQUIRE(n->components.size() == 3);
+                REQUIRE(n.components.size() == 3);
             }
         }
     }
@@ -47,9 +47,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {
             REQUIRE(parse_result.has_value());
             CHECK(parse_result.value().diagnostics.size() == 4); // TODO: The success state should not result in diagnostics
             auto n = std::move(parse_result.value().ntta);
-            std::cout << *n << std::endl;
+            std::cout << n << std::endl;
             THEN("six TTAs are constructed (fischer instances + main)") {
-                REQUIRE(n->components.size() == 6);
+                REQUIRE(n.components.size() == 6);
             }
         }
     }
@@ -60,9 +60,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {
             CHECK(parse_result.value().diagnostics.size() == 9); // TODO: The success state should not result in diagnostics
             REQUIRE(parse_result.has_value());
             auto n = std::move(parse_result.value().ntta);
-            std::cout << *n << std::endl;
+            std::cout << n << std::endl;
             THEN("eleven TTAs are constructed (fischer instances + main)") {
-                REQUIRE(n->components.size() == 11);
+                REQUIRE(n.components.size() == 11);
             }
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -256,7 +256,7 @@ namespace aaltitoad::hawk {`
`256`	`256`	`builder.add_symbols(internal_symbols);`
`257`	`257`	`builder.add_external_symbols(external_symbols);`
`258`	`258`	`return plugin::parse_ok{`
`259`		`- .ntta=std::unique_ptr<ntta_t>{builder.build_heap()},`
	`259`	`+ .ntta=builder.build(),`
`260`	`260`	`.diagnostics=diagnostics`
`261`	`261`	`};`
`262`	`262`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,9 +34,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {`
`34`	`34`	`REQUIRE(parse_result.has_value());`
`35`	`35`	`CHECK(parse_result.value().diagnostics.size() == 1); // TODO: The success state should not result in diagnostics`
`36`	`36`	`auto n = std::move(parse_result.value().ntta);`
`37`		`- std::cout << *n << std::endl;`
	`37`	`+ std::cout << n << std::endl;`
`38`	`38`	`THEN("three TTAs are constructed (Main, fischer1, and fischer2)") {`
`39`		`- REQUIRE(n->components.size() == 3);`
	`39`	`+ REQUIRE(n.components.size() == 3);`
`40`	`40`	`}`
`41`	`41`	`}`
`42`	`42`	`}`
`@@ -47,9 +47,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {`
`47`	`47`	`REQUIRE(parse_result.has_value());`
`48`	`48`	`CHECK(parse_result.value().diagnostics.size() == 4); // TODO: The success state should not result in diagnostics`
`49`	`49`	`auto n = std::move(parse_result.value().ntta);`
`50`		`- std::cout << *n << std::endl;`
	`50`	`+ std::cout << n << std::endl;`
`51`	`51`	`THEN("six TTAs are constructed (fischer instances + main)") {`
`52`		`- REQUIRE(n->components.size() == 6);`
	`52`	`+ REQUIRE(n.components.size() == 6);`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`	`}`
`@@ -60,9 +60,9 @@ SCENARIO("parsing fischer-n suite", "[hawk_parser]") {`
`60`	`60`	`CHECK(parse_result.value().diagnostics.size() == 9); // TODO: The success state should not result in diagnostics`
`61`	`61`	`REQUIRE(parse_result.has_value());`
`62`	`62`	`auto n = std::move(parse_result.value().ntta);`
`63`		`- std::cout << *n << std::endl;`
	`63`	`+ std::cout << n << std::endl;`
`64`	`64`	`THEN("eleven TTAs are constructed (fischer instances + main)") {`
`65`		`- REQUIRE(n->components.size() == 11);`
	`65`	`+ REQUIRE(n.components.size() == 11);`
`66`	`66`	`}`
`67`	`67`	`}`
`68`	`68`	`}`