feat(template): V6 compiler optimization with execution plan

Introduce a new compilation pipeline transforming AST into an instruction-based execution plan.

Core changes:
- add Instruction and ExecutionPlan (linear instruction model)
- introduce Optimizer (AST normalization, text merging)
- implement Compiler pipeline: optimize -> build execution plan
- upgrade Template to support execution plan rendering
- update Renderer to execute compiled plans (with filters support)
- preserve extends/block inheritance via AST fallback path
- fix string literal handling and filter propagation

Architecture:
- move from AST interpreter to execution plan (bytecode-like model)
- improve rendering performance and CPU efficiency
- establish foundation for future optimizations (constant folding, JIT)

Environment:
- now uses Compiler instead of direct Template construction

Benchmarks:
- add render benchmark (Google Benchmark optional)
- add cache benchmark
- measure performance across expressions, loops, includes

Tests:
- update compiler, renderer, integration tests for V6
- fix cache test to support ExecutionPlan
- improve coverage for filters, expressions, inheritance

Build:
- make benchmarks optional in CMake
- fix benchmark linking (benchmark::benchmark)

This release introduces a major internal redesign of the rendering engine,
shifting to a compiled execution model for better performance and scalability.

Author: GaspardKirira

CMakeLists.txt

@@ -52,6 +52,7 @@ add_library(template
   src/StringLoader.cpp
   src/Template.cpp
   src/Value.cpp
+  src/Optimizer.cpp
 )
 
 add_library(vix::template ALIAS template)
@@ -115,7 +116,13 @@ endif()
 # ============================================================================
 
 if(TEMPLATE_BUILD_BENCHMARKS)
-  add_subdirectory(benchmarks)
+  find_package(benchmark QUIET)
+
+  if(benchmark_FOUND)
+    add_subdirectory(benchmarks)
+  else()
+    message(STATUS "Google Benchmark not found, benchmarks will not be built")
+  endif()
 endif()
 
 # ============================================================================

benchmarks/CMakeLists.txt

@@ -4,15 +4,22 @@ if(NOT TARGET vix::template)
   message(FATAL_ERROR "Target vix::template not found")
 endif()
 
+if(NOT TARGET benchmark::benchmark)
+  message(FATAL_ERROR "Target benchmark::benchmark not found")
+endif()
+
 add_executable(template_render_bench
   render_bench.cpp
 )
 
 target_link_libraries(template_render_bench
   PRIVATE
     vix::template
+    benchmark::benchmark
 )
 
+target_compile_features(template_render_bench PRIVATE cxx_std_20)
+
 add_executable(template_parse_bench
   parse_bench.cpp
 )
@@ -22,6 +29,8 @@ target_link_libraries(template_parse_bench
     vix::template
 )
 
+target_compile_features(template_parse_bench PRIVATE cxx_std_20)
+
 add_executable(template_cache_bench
   cache_bench.cpp
 )
@@ -31,6 +40,8 @@ target_link_libraries(template_cache_bench
     vix::template
 )
 
+target_compile_features(template_cache_bench PRIVATE cxx_std_20)
+
 set_target_properties(
   template_render_bench
   template_parse_bench

benchmarks/cache_bench.cpp

@@ -20,6 +20,7 @@
 #include <string>
 
 #include <vix/template/Cache.hpp>
+#include <vix/template/ExecutionPlan.hpp>
 #include <vix/template/Template.hpp>
 
 using namespace vix::template_;
@@ -63,7 +64,10 @@ class MemoryCache : public Cache
 
 static TemplatePtr make_template(const std::string &name)
 {
-  return std::make_shared<Template>(name, RootNode{});
+  return std::make_shared<Template>(
+      name,
+      RootNode{},
+      ExecutionPlan{});
 }
 
 int main()

benchmarks/render_bench.cpp

@@ -13,71 +13,198 @@
  *  Vix.cpp
  *
  */
-#include <chrono>
-#include <iostream>
+#include <benchmark/benchmark.h>
+
+#include <memory>
 #include <string>
+#include <utility>
 
+#include <vix/template/Compiler.hpp>
+#include <vix/template/Context.hpp>
 #include <vix/template/Lexer.hpp>
 #include <vix/template/Parser.hpp>
-#include <vix/template/Renderer.hpp>
-#include <vix/template/Context.hpp>
+#include <vix/template/StringLoader.hpp>
+#include <vix/template/Template.hpp>
 
 using namespace vix::template_;
 
-static RootNode build_ast(const std::string &tpl)
+namespace
 {
-  Lexer lexer(tpl);
-  auto tokens = lexer.tokenize();
+  [[nodiscard]] Template compile_template(
+      const std::string &name,
+      const std::string &source,
+      std::shared_ptr<Loader> loader = nullptr)
+  {
+    Lexer lexer(source);
+    auto tokens = lexer.tokenize();
+
+    Parser parser(std::move(tokens));
+    RootNode root = parser.parse();
+
+    Compiler compiler;
+    return compiler.compile(name, std::move(root), std::move(loader));
+  }
+
+  [[nodiscard]] Context make_basic_context()
+  {
+    Context ctx;
+    ctx.set("name", "Alice");
+    ctx.set("bio", "offline-first systems");
+    ctx.set("price", 6);
+    ctx.set("quantity", 7);
+    ctx.set("enabled", true);
+
+    Object user;
+    user["name"] = Value("Alice");
+    user["role"] = Value("admin");
+    ctx.set("user", user);
+
+    Array items;
+    items.emplace_back("Book");
+    items.emplace_back("Phone");
+    items.emplace_back("Pen");
+    items.emplace_back("Bag");
+    items.emplace_back("Mouse");
+    ctx.set("items", items);
+
+    return ctx;
+  }
+
+} // namespace
 
-  Parser parser(std::move(tokens));
-  return parser.parse();
+static void BM_render_plain_text(benchmark::State &state)
+{
+  const Template tpl = compile_template(
+      "plain_text",
+      "Hello world. This is a simple static template used for benchmarking.");
+  const Context ctx;
+
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
+
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
 }
+BENCHMARK(BM_render_plain_text);
 
-int main()
+static void BM_render_variable(benchmark::State &state)
 {
-  const std::string tpl =
-      "<h1>{{ title }}</h1>\n"
-      "{% if user %}Hello {{ user }}{% endif %}\n"
-      "<ul>\n"
-      "{% for item in items %}<li>{{ item }}</li>{% endfor %}\n"
-      "</ul>";
+  const Template tpl = compile_template(
+      "variable",
+      "Hello {{ name }}");
+  const Context ctx = make_basic_context();
 
-  // Build AST once (simulate compiled template)
-  RootNode root = build_ast(tpl);
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
 
-  // Prepare context
-  Context ctx;
-  ctx.set("title", "Benchmark");
-  ctx.set("user", "Gaspard");
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
+}
+BENCHMARK(BM_render_variable);
 
-  Array items;
-  items.emplace_back("Laptop");
-  items.emplace_back("Phone");
-  items.emplace_back("Book");
-  ctx.set("items", items);
+static void BM_render_expression(benchmark::State &state)
+{
+  const Template tpl = compile_template(
+      "expression",
+      "{{ price * quantity }}");
+  const Context ctx = make_basic_context();
 
-  Renderer renderer(true);
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
+
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
+}
+BENCHMARK(BM_render_expression);
+
+static void BM_render_if(benchmark::State &state)
+{
+  const Template tpl = compile_template(
+      "if_template",
+      "{% if enabled %}Hello {{ name }}{% endif %}");
+  const Context ctx = make_basic_context();
 
-  const int iterations = 100000;
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
 
-  auto start = std::chrono::high_resolution_clock::now();
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
+}
+BENCHMARK(BM_render_if);
+
+static void BM_render_for_loop(benchmark::State &state)
+{
+  const Template tpl = compile_template(
+      "for_loop",
+      "{% for item in items %}[{{ item }}]{% endfor %}");
+  const Context ctx = make_basic_context();
 
-  for (int i = 0; i < iterations; ++i)
+  for (auto _ : state)
   {
-    auto result = renderer.render(root, ctx);
-    (void)result;
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
   }
 
-  auto end = std::chrono::high_resolution_clock::now();
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
+}
+BENCHMARK(BM_render_for_loop);
+
+static void BM_render_mixed_template(benchmark::State &state)
+{
+  const Template tpl = compile_template(
+      "mixed",
+      "Hello {{ user.name }}\n"
+      "{% if enabled %}"
+      "Role: {{ user.role }}\n"
+      "Total: {{ price * quantity }}\n"
+      "{% endif %}"
+      "Items: {% for item in items %}[{{ item | upper }}]{% endfor %}");
+  const Context ctx = make_basic_context();
+
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
 
-  const auto duration =
-      std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
+}
+BENCHMARK(BM_render_mixed_template);
 
-  std::cout << "Render benchmark\n";
-  std::cout << "Iterations: " << iterations << '\n';
-  std::cout << "Total time (ms): " << duration.count() << '\n';
-  std::cout << "Avg per render (us): "
-            << (duration.count() * 1000.0 / iterations) << '\n';
+static void BM_render_include(benchmark::State &state)
+{
+  auto loader = std::make_shared<StringLoader>();
+  loader->set("header.html", "Header {{ name }}\n");
+  loader->set("body.html", "{% include \"header.html\" %}Total: {{ price * quantity }}");
+  const Template tpl = compile_template(
+      "include_template",
+      "{% include \"body.html\" %}",
+      loader);
+  const Context ctx = make_basic_context();
+
+  for (auto _ : state)
+  {
+    const RenderResult result = tpl.render(ctx);
+    benchmark::DoNotOptimize(result.output);
+  }
 
-  return 0;
+  state.SetItemsProcessed(
+      static_cast<std::int64_t>(state.iterations()));
 }
+BENCHMARK(BM_render_include);
+
+BENCHMARK_MAIN();