function definition class structure changed, corresponding builders and printers fixes, fixes

include/basic_printers.hpp

@@ -118,6 +118,8 @@ private:
   size_t indentation_level_ = 0;
 };
 
+void print_modifier(const nodes::Modifier &modifier, Printer &printer);
+
 void print_literal(const nodes::Literal &literal, Printer &printer);
 
 void print_identifier(const nodes::Identifier &identifier, Printer &printer);

include/expression_nodes.hpp

@@ -24,10 +24,10 @@ public:
 
 private:
   ExpressionProxy(ExpressionStorage &expression_storage, size_t id)
-      : expression_storage_(expression_storage), id_(id) {}
+      : expression_storage_(&expression_storage), id_(id) {}
 
 private:
-  ExpressionStorage &expression_storage_;
+  ExpressionStorage *expression_storage_;
   size_t id_;
 };
 

include/statement_nodes.hpp

@@ -66,24 +66,138 @@ public:
     VAR,
   };
 
+  class Argument {
+  public:
+    Argument(const std::optional<std::string> &annotation, Identifier &&name,
+             Modifier before_modifier = Modifier::NONE,
+             Modifier after_modifier = Modifier::NONE)
+        : annotation_(annotation), name_(std::move(name)),
+          before_modifier_(before_modifier), after_modifier_(after_modifier) {}
+
+    Argument(const std::optional<std::string> &annotation,
+             const Identifier &name, Modifier before_modifier = Modifier::NONE,
+             Modifier after_modifier = Modifier::NONE)
+        : annotation_(annotation), name_(name),
+          before_modifier_(before_modifier), after_modifier_(after_modifier) {}
+
+    Argument(const std::optional<std::string> &annotation, TypeProxy type,
+             Modifier before_modifier = Modifier::NONE)
+        : annotation_(annotation), type_(type),
+          before_modifier_(before_modifier),
+          after_modifier_(type.get()->get_modifier()) {}
+
+    //
+
+    bool add_type(const std::optional<std::string> &annotation, TypeProxy type,
+                  nodes::Modifier before_modifier = Modifier::NONE) {
+      if (annotation_.has_value() &&
+          (!annotation.has_value() ||
+           annotation_.value() != annotation.value())) {
+        return false;
+      }
+
+      if (before_modifier_ != Modifier::NONE &&
+          before_modifier_ != before_modifier) {
+        return false;
+      }
+
+      if (after_modifier_ != Modifier::NONE &&
+          after_modifier_ != type.get()->get_modifier()) {
+        return false;
+      }
+
+      annotation_ = annotation;
+      type_ = type;
+      before_modifier_ = before_modifier;
+      after_modifier_ = type.get()->get_modifier();
+
+      return true;
+    }
+
+    bool add_annotation(const std::string &annotation) {
+      if (annotation_.has_value()) {
+        return false;
+      }
+
+      annotation_ = annotation;
+
+      return true;
+    }
+
+    //
+
+    std::optional<std::string *> get_annotation() {
+      if (annotation_.has_value()) {
+        return &annotation_.value();
+      }
+      return std::nullopt;
+    }
+
+    std::optional<const std::string *> get_annotation() const {
+      if (annotation_.has_value()) {
+        return &annotation_.value();
+      }
+      return std::nullopt;
+    }
+
+    //
+
+    std::optional<Identifier *> get_name() {
+      if (name_.has_value()) {
+        return &name_.value();
+      }
+      return std::nullopt;
+    }
+
+    std::optional<const Identifier *> get_name() const {
+      if (name_.has_value()) {
+        return &name_.value();
+      }
+      return std::nullopt;
+    }
+
+    //
+
+    std::optional<Type *> get_type() {
+      if (type_.has_value()) {
+        return type_.value().get();
+      }
+      return std::nullopt;
+    }
+
+    std::optional<const Type *> get_type() const {
+      if (type_.has_value()) {
+        return type_.value().get();
+      }
+      return std::nullopt;
+    }
+
+    //
+
+    Modifier get_before_modifier() const { return before_modifier_; }
+
+    Modifier get_after_modifier() const { return after_modifier_; }
+
+  private:
+    std::optional<std::string> annotation_;
+    std::optional<Identifier> name_; // no name for output arguments
+    std::optional<TypeProxy> type_;  // no type if it is deduced
+    Modifier before_modifier_ =
+        Modifier::NONE; // in, out, ref, none // sync with type
+    Modifier after_modifier_ =
+        Modifier::NONE; // optional, result, none // sync with type
+  };
+
   FunctionDefinition(Node node, SymbolDocs &&docs,
                      std::vector<Constraint> &&constraints,
                      ModifierType modifier, const Identifier &name,
-                     std::vector<std::optional<std::string>> &&annotations,
-                     std::vector<Identifier> &&arguments,
-                     std::vector<Modifier> &&reference_types,
-                     std::vector<TypeProxy> &&types,
-                     std::vector<bool> &&optional_arguments,
-                     std::vector<bool> &&result_arguments,
-                     bool is_annotations_same_to_names,
+                     std::vector<Argument> &&arguments,
+                     bool are_annotations_same_to_names,
                      std::optional<ExpressionProxy> expression)
       : Node(node), docs_(std::move(docs)),
         constraints_(std::move(constraints)), modifier_(modifier), name_(name),
-        annotations_(std::move(annotations)), arguments_(std::move(arguments)),
-        reference_types_(std::move(reference_types)), types_(std::move(types)),
-        optional_arguments_(optional_arguments),
-        result_arguments_(result_arguments),
-        is_annotations_same_to_names_(is_annotations_same_to_names),
+        arguments_(std::move(arguments)),
+        are_annotations_same_to_names_(are_annotations_same_to_names),
         expression_(expression) {}
 
   //
@@ -114,57 +228,11 @@ public:
 
   //
 
-  std::optional<std::string *> get_argument_annotation(size_t id) {
-    if (annotations_.at(id).has_value()) {
-      return &annotations_[id].value();
-    }
-    return std::nullopt;
-  }
-
-  std::optional<const std::string *> get_argument_annotation(size_t id) const {
-    if (annotations_.at(id).has_value()) {
-      return &annotations_[id].value();
-    }
-    return std::nullopt;
-  }
-
-  //
-
   size_t get_arguments_size() const { return arguments_.size(); }
 
-  Identifier *get_argument(size_t id) { return &arguments_.at(id); }
+  Argument *get_argument(size_t id) { return &arguments_.at(id); }
 
-  const Identifier *get_argument(size_t id) const { return &arguments_.at(id); }
-
-  //
-
-  Modifier get_argument_reference_type(size_t id) const {
-    return reference_types_.at(id);
-  }
-
-  //
-
-  size_t get_argument_types_size() const { return types_.size(); }
-
-  Type *get_argument_type(size_t id) { return types_.at(id).get(); }
-
-  const Type *get_argument_type(size_t id) const { return types_.at(id).get(); }
-
-  //
-
-  bool is_argument_optional(size_t id) const {
-    return optional_arguments_.at(id);
-  }
-
-  //
-
-  bool is_argument_result(size_t id) const { return result_arguments_.at(id); }
-
-  //
-
-  bool is_annotations_same_to_names() const {
-    return is_annotations_same_to_names_;
-  }
+  const Argument *get_argument(size_t id) const { return &arguments_.at(id); }
 
   //
 
@@ -182,18 +250,19 @@ public:
     return std::nullopt;
   }
 
+  //
+
+  bool are_annotations_same_to_names() const {
+    return are_annotations_same_to_names_;
+  }
+
 private:
   SymbolDocs docs_;
   std::vector<Constraint> constraints_;
   ModifierType modifier_;
   Identifier name_;
-  std::vector<std::optional<std::string>> annotations_;
-  std::vector<Identifier> arguments_;
-  std::vector<Modifier> reference_types_;
-  std::vector<TypeProxy> types_;
-  std::vector<bool> optional_arguments_;
-  std::vector<bool> result_arguments_;
-  bool is_annotations_same_to_names_;
+  std::vector<Argument> arguments_;
+  bool are_annotations_same_to_names_; // needed for easier prinitng process
   std::optional<ExpressionProxy> expression_;
 }; // refactor ??
 

include/type_nodes.hpp

@@ -24,10 +24,10 @@ public:
 
 private:
   TypeProxy(TypeStorage &type_storage, size_t id)
-      : type_storage_(type_storage), id_(id) {}
+      : type_storage_(&type_storage), id_(id) {}
 
 private:
-  TypeStorage &type_storage_;
+  TypeStorage *type_storage_;
   size_t id_;
 };
 
@@ -35,28 +35,26 @@ private:
 class Type : public Node {
 public:
   Type(Node node, Identifier &&identifier, bool is_on_heap = false,
-       bool is_optional = false, bool is_result = false)
+       Modifier modifier = Modifier::NONE)
       : Node(node), name_(std::move(identifier)), is_on_heap_(is_on_heap),
-        is_optional_(is_optional), is_result_(is_result) {}
+        modifier_(modifier) {}
 
   Type(Node node, const Identifier &identifier, bool is_on_heap = false,
-       bool is_optional = false, bool is_result = false)
+       Modifier modifier = Modifier::NONE)
       : Node(node), name_(identifier), is_on_heap_(is_on_heap),
-        is_optional_(is_optional), is_result_(is_result) {}
+        modifier_(modifier) {}
 
   Type(Node node, Identifier &&identifier, std::vector<TypeProxy> &&parameters,
-       bool is_on_heap = false, bool is_optional = false,
-       bool is_result = false)
+       bool is_on_heap = false, Modifier modifier = Modifier::NONE)
       : Node(node), name_(std::move(identifier)),
         parameters_(std::move(parameters)), is_on_heap_(is_on_heap),
-        is_optional_(is_optional), is_result_(is_result) {}
+        modifier_(modifier) {}
 
   Type(Node node, const Identifier &identifier,
        std::vector<TypeProxy> &&parameters, bool is_on_heap = false,
-       bool is_optional = false, bool is_result = false)
+       Modifier modifier = Modifier::NONE)
       : Node(node), name_(identifier), parameters_(std::move(parameters)),
-        is_on_heap_(is_on_heap), is_optional_(is_optional),
-        is_result_(is_result) {}
+        is_on_heap_(is_on_heap), modifier_(modifier) {}
 
   Identifier *get_name() { return &name_; }
 
@@ -72,17 +70,14 @@ public:
 
   bool is_on_heap() const { return is_on_heap_; }
 
-  bool is_optional() const { return is_optional_; }
-
-  bool is_result() const { return is_result_; }
+  Modifier get_modifier() const { return modifier_; }
 
 private:
   Identifier name_;
   std::vector<TypeProxy> parameters_;
   // or use allocator ??
   bool is_on_heap_ = false;
-  bool is_optional_ = false;
-  bool is_result_ = false;
+  Modifier modifier_ = Modifier::NONE; // optional, result or none
 };
 
 class TypeStorage {