WIP: Lifetimes

Author: jansvoboda11

example/include/example/ast.hpp

@@ -8,21 +8,43 @@ struct expr;
 
 struct literal {
   char value;
+
+  constexpr explicit literal(char v) : value(v) {}
 };
 
 struct variable {
   char name;
+
+  constexpr explicit variable(char n) : name(n) {}
 };
 
 struct call {
   char name;
   const expr *arg1;
   const expr *arg2;
+
+  constexpr explicit call(char n, const expr *a1, const expr *a2) : name(n), arg1(a1), arg2(a2) {}
+
+  constexpr ~call();
 };
 
 struct expr {
   percy::variant<literal, variable, call> value;
+
+  constexpr explicit expr(literal l) : value(std::move(l)) {}
+  constexpr explicit expr(variable v) : value(std::move(v)) {}
+  constexpr explicit expr(call c) : value(std::move(c)) {}
 };
+
+struct ast {
+  const expr *expression;
+
+  constexpr explicit ast(const expr *e) : expression(e) {}
+
+  constexpr ~ast() { int x = 0; }
+};
+
+constexpr call::~call() { delete arg1; delete arg2; }
 } // namespace example::ast
 
 #endif

example/include/example/grammar.hpp

@@ -48,7 +48,7 @@ struct expr {
 struct top {
   using rule = sequence<expr, end>;
 
-  constexpr static auto action(ast::expr *expr, eof _) { return expr; }
+  constexpr static auto action(ast::expr *expr, eof _) { return ast::ast(expr); }
 };
 } // namespace example::grammar
 

example/input.txt

@@ -1 +1 @@
-a(x,2)
+2

include/percy/parser.hpp

@@ -56,7 +56,10 @@ struct parser<Rule, std::enable_if_t<is_sequence_v<typename Rule::rule>>> {
       return raw_result.failure();
     }
 
-    return succeed(std::apply(Rule::action, raw_result->get()), raw_result->span());
+    auto result0 = raw_result->get();
+    auto result1 = std::apply(Rule::action, result0);
+    auto success = succeed(std::move(result1), raw_result->span());
+    return std::move(success);
   }
 };
 
@@ -105,7 +108,7 @@ struct parser<range<Begin, End>> {
     }
 
     if (auto symbol = input.peek(); Begin <= symbol && symbol <= End) {
-      return succeed(symbol, {input.loc(), 1});
+      return succeed(std::move(symbol), {input.loc(), 1});
     }
 
     return fail("Range.", input.loc());
@@ -182,7 +185,7 @@ struct parser<sequence<Rule, FollowingRule, FollowingRules...>> {
     }
 
     auto value = std::tuple_cat(result->get(), following_result->get());
-    return succeed(value, {result->begin(), following_result->end()});
+    return succeed(std::move(value), {result->begin(), following_result->end()});
   }
 };
 

include/percy/result.hpp

@@ -23,24 +23,37 @@ constexpr failure_t fail(std::string_view message, input_location location) {
 
 template <typename Node>
 class success_t {
-  Node node_;
+  struct empty {};
+
+  percy::variant<Node, empty> node_;
   input_span span_;
 
 public:
   using value_type = Node;
 
-  constexpr success_t(Node node, input_span span) : node_(node), span_(span) {}
+  constexpr success_t(Node &&node, input_span span)
+      : node_(std::forward<Node>(node)), span_(span) {}
+
+  constexpr Node get() {
+    Node node = percy::get<Node>(node_);
+    node_ = empty{};
+    return std::move(node);
+  }
 
-  constexpr Node get() { return node_; }
+  constexpr Node get() const {
+    return percy::get<Node>(node_);
+  }
 
   constexpr input_span span() const { return span_; }
   constexpr input_location begin() const { return span_.begin(); }
   constexpr input_location end() const { return span_.end(); }
+
+  constexpr ~success_t() = default;
 };
 
 template <typename Node>
-constexpr success_t<Node> succeed(Node node, input_span span) {
-  return success_t<Node>(node, span);
+constexpr success_t<Node> succeed(Node &&node, input_span span) {
+  return success_t<Node>(std::forward<Node>(node), span);
 }
 
 template <typename Node>
@@ -49,16 +62,19 @@ class result {
   using success_type = success_t<Node>;
   using failure_type = failure_t;
 
-  constexpr result(success_type value) : value_(value) {}
+  constexpr result(success_type&& value) : value_(std::move(value)) {}
   constexpr result(failure_type value) : value_(value) {}
 
   constexpr operator bool() const { return is_success(); }
   constexpr bool is_success() const { return percy::holds_alternative<success_type>(value_); }
   constexpr bool is_failure() const { return !is_success(); }
 
+  constexpr const success_type *operator->() const { return &percy::get<success_type>(value_); }
   constexpr success_type *operator->() { return &percy::get<success_type>(value_); }
   constexpr failure_t failure() const { return percy::get<failure_type>(value_); }
 
+  constexpr ~result() = default;
+
 private:
   percy::variant<success_type, failure_type> value_;
 };

tests/percy/parser.cpp

@@ -167,6 +167,26 @@ TEST_CASE("Parser sequence fails when following rule does not match.", "[parser]
   STATIC_REQUIRE(result.failure().loc() == 1);
 }
 
+static testing::context ctx();
+
+namespace percy {
+struct parser<testing::tracker1> {
+  using result_type = result<eof>;
+
+  constexpr static result_type parse(Input input) {
+    return succeed(testing::tracker1(&ctx), {input.loc(), input.loc() + 1});
+  }
+};
+}
+
+TEST_CASE("Parser sequence correctly handles lifetimes.", "[parser][sequence]") {
+  using parser = percy::parser<percy::sequence<testing::tracker1>>;
+
+  PERCY_CONSTEXPR auto result - parser::parse(percy::input("xxx"));
+
+  //
+}
+
 TEST_CASE("Parser either succeeds when first rule matches.", "[parser][either]") {
   using parser = percy::parser<percy::either<percy::symbol<'a'>, percy::symbol<'b'>>>;
 
@@ -236,7 +256,7 @@ TEST_CASE("Parser one_of fails when no rule matches.", "[parser][one_of]") {
 TEST_CASE("Parser many succeeds even when rule matches zero times.", "[parser][many]") {
   using parser = percy::parser<percy::many<percy::symbol<'x'>>>;
 
-  PERCY_CONSTEXPR auto result = parser::parse(percy::input("abc"));
+  auto result = parser::parse(percy::input("abc"));
 
   REQUIRE(result.is_success());
   REQUIRE(result->begin() == 0);
@@ -247,7 +267,7 @@ TEST_CASE("Parser many succeeds even when rule matches zero times.", "[parser][m
 TEST_CASE("Parser many succeeds when rule matches multiple times.", "[parser][many]") {
   using parser = percy::parser<percy::many<percy::symbol<'a'>>>;
 
-  PERCY_CONSTEXPR auto result = parser::parse(percy::input("aac"));
+  auto result = parser::parse(percy::input("aac"));
 
   REQUIRE(result.is_success());
   REQUIRE(result->begin() == 0);
@@ -258,7 +278,7 @@ TEST_CASE("Parser many succeeds when rule matches multiple times.", "[parser][ma
 TEST_CASE("Parser many stops at the input end.", "[parser][many]") {
   using parser = percy::parser<percy::many<percy::symbol<'a'>>>;
 
-  PERCY_CONSTEXPR auto result = parser::parse(percy::input("aaa"));
+  auto result = parser::parse(percy::input("aaa"));
 
   REQUIRE(result.is_success());
   REQUIRE(result->begin() == 0);