Add OOL dtor defs to fix unique_ptr issues

Author: jarzec

source/parse.h

@@ -145,6 +145,9 @@ struct primary_expression_node
     // Cache to work around <https://github.com/llvm/llvm-project/issues/73336>.
     bool expression_list_is_fold_expression = false;
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~primary_expression_node();
 
     //  API
     //
@@ -238,6 +241,10 @@ struct prefix_expression_node
     std::vector<token const*> ops;
     std::unique_ptr<postfix_expression_node> expr;
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~prefix_expression_node();
+
     //  API
     //
     auto is_fold_expression() const
@@ -297,6 +304,10 @@ struct binary_expression_node
 
     binary_expression_node();
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used as Term in a std::unique_ptr as a member
+    ~binary_expression_node();
+
     struct term
     {
         token const* op;
@@ -1090,6 +1101,18 @@ struct template_argument
         std::unique_ptr<type_id_node>
     > arg;
 
+    // The type needs to be movable
+    // The copy ctor+operator are implicitly deleted due to the std::unique_ptr member
+    // Because a forward-declared type is used in a std::unique_ptr as a member an out-of-line dtor is necessary
+    // Because of the OOL dtor together with the fact that the copy ctor+operator are deleted
+    // the move ctor+operator need to be explicitly defaulted
+    // As a result the default constructor also needs to be explicitly defaulted
+    template_argument() = default;
+    template_argument(template_argument&&) = default;
+    template_argument& operator=(template_argument&&) = default;
+
+    ~template_argument();
+
     auto to_string() const
         -> std::string;
 };
@@ -1803,6 +1826,10 @@ struct iteration_statement_node
     std::unique_ptr<statement_node>             body;               // used for "for", else null
     bool                                        for_with_in = false;// used for "for," says whether loop variable is 'in'
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~iteration_statement_node();
+
     auto position() const
         -> source_position
     {
@@ -1854,6 +1881,10 @@ struct alternative_node
     source_position                      equal_sign;
     std::unique_ptr<statement_node>      statement;
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~alternative_node();
+
     auto position() const
         -> source_position
     {
@@ -1877,6 +1908,10 @@ struct inspect_expression_node
 
     std::vector<std::unique_ptr<alternative_node>> alternatives;
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~inspect_expression_node();
+
     auto position() const
         -> source_position
     {
@@ -2014,6 +2049,10 @@ struct statement_node
 
     statement_node(compound_statement_node* compound_parent_ = nullptr);
 
+    // Out-of-line definition of the dtor is necessary due to the forward-declared
+    // type(s) used in a std::unique_ptr as a member
+    ~statement_node();
+
     enum active { expression=0, compound, selection, declaration, return_, iteration, using_, contract, inspect, jump };
     std::variant<
         std::unique_ptr<expression_statement_node>,
@@ -4389,6 +4428,26 @@ struct translation_unit_node
     }
 };
 
+// Definitions of out-of-line dtors for nodes with unique_ptr members of forward-declared types
+primary_expression_node::~primary_expression_node() = default;
+
+prefix_expression_node::~prefix_expression_node() = default;
+
+template<
+    String   Name,
+    typename Term
+>
+binary_expression_node<Name, Term>::~binary_expression_node() = default;
+
+alternative_node::~alternative_node() = default;
+
+iteration_statement_node::~iteration_statement_node() = default;
+
+template_argument::~template_argument() = default;
+
+inspect_expression_node::~inspect_expression_node() = default;
+
+statement_node::~statement_node() = default;
 
 //-----------------------------------------------------------------------
 //