combine functions for statements part done

include/statement_nodes.hpp

@@ -11,6 +11,19 @@
 
 namespace nodes {
 
+enum class CombineResult {
+  DIFFERENT_NAME_ERROR,
+  DIFFERNENT_MODIFIER_ERROR,
+  MORE_THEN_ONE_DOCS_ERROR,
+  MORE_THEN_ONE_CONSTRAINTS_ERROR,
+  MORE_THEN_ONE_DEFINITION_BODY_ERROR,
+  ARGUMENTS_ERROR,
+  DIFFERENT_STATEMENT_TYPES,
+  STATEMENTS_CANT_BE_COMBINED_ERROR,
+  GENERIC_ERROR,
+  OK,
+};
+
 // IN PROGRESS: add another constructors ??
 class Import : public Node {
 public:
@@ -88,8 +101,42 @@ public:
 
     //
 
+    // add type with same annotation and same before_modifier
+    bool update_type_from(const Argument &other_argument) {
+      if (type_.has_value() || !other_argument.type_.has_value()) {
+        return false;
+      }
+
+      if (annotation_.has_value() &&
+          (!other_argument.annotation_.has_value() ||
+           annotation_.value() != other_argument.annotation_.value())) {
+        return false;
+      }
+
+      if (before_modifier_ != other_argument.before_modifier_) {
+        return false;
+      }
+
+      if (after_modifier_ != other_argument.after_modifier_) {
+        return false;
+      }
+
+      annotation_ = other_argument.annotation_;
+      type_ = other_argument.type_;
+      before_modifier_ = other_argument.before_modifier_;
+      after_modifier_ = other_argument.after_modifier_;
+
+      return true;
+    }
+
+    // check, that argument modifiers are none or same to different from type
+    // modifiers
     bool add_type(const std::optional<std::string> &annotation, TypeProxy type,
                   nodes::Modifier before_modifier = Modifier::NONE) {
+      if (type_.has_value()) {
+        return false;
+      }
+
       if (annotation_.has_value() &&
           (!annotation.has_value() ||
            annotation_.value() != annotation.value())) {
@@ -258,7 +305,9 @@ public:
 
   //
 
-  bool combine(FunctionDefinition &&other_function_definition);
+  bool is_same_to(const FunctionDefinition &other_function_definition) const;
+
+  CombineResult combine(FunctionDefinition &&other_function_definition);
 
 private:
   SymbolDocs docs_;
@@ -278,7 +327,11 @@ public:
                  std::vector<FunctionDefinition> &&methods)
       : Node(node), docs_(std::move(docs)), is_on_heap_(is_on_heap),
         name_(name), arguments_(std::move(arguments)), type_(std::move(type)),
-        methods_(std::move(methods)) {}
+        methods_(std::move(methods)) {
+    for (size_t i = 0; i < methods.size(); ++i) {
+      methods_by_name_[*methods_[i].get_name()->get()] = i;
+    }
+  }
 
   //
 
@@ -332,7 +385,9 @@ public:
 
   //
 
-  bool combine(TypeDefinition &&other_type_definition);
+  bool is_same_to(const TypeDefinition &other_type_definition) const;
+
+  CombineResult combine(TypeDefinition &&other_type_definition);
 
 private:
   SymbolDocs docs_;
@@ -340,6 +395,8 @@ private:
   Identifier name_;
   std::vector<Identifier> arguments_;
   std::optional<VariantType> type_; // TupleType is VariantType with one variant
+  std::unordered_map<std::string, size_t>
+      methods_by_name_; // methods can't be overloaded ??
   std::vector<FunctionDefinition> methods_;
 };
 
@@ -350,7 +407,11 @@ public:
                       std::vector<FunctionDefinition> &&methods)
       : Node(node), docs_(std::move(docs)), name_(name),
         base_typeclasses_(std::move(base_typeclasses)),
-        methods_(std::move(methods)) {}
+        methods_(std::move(methods)) {
+    for (size_t i = 0; i < methods.size(); ++i) {
+      methods_by_name_[*methods_[i].get_name()->get()] = i;
+    }
+  }
 
   //
 
@@ -388,12 +449,16 @@ public:
 
   //
 
-  bool combine(TypeclassDefinition &&other_typeclass_definition);
+  bool is_same_to(const TypeclassDefinition &other_typeclass_definition) const;
+
+  CombineResult combine(TypeclassDefinition &&other_typeclass_definition);
 
 private:
   SymbolDocs docs_;
   Identifier name_;
   std::vector<Identifier> base_typeclasses_;
+  std::unordered_map<std::string, size_t>
+      methods_by_name_; // methods can't be overloaded ??
   std::vector<FunctionDefinition> methods_;
 };
 
@@ -420,6 +485,10 @@ public:
 
   auto get_any() const { return &expression_; }
 
+  bool is_same_to(const Statement &other_statement) const;
+
+  CombineResult combine(Statement &&other_statement);
+
 private:
   std::variant<Import, TypeDefinition, FunctionDefinition, TypeclassDefinition,
                EmptyLines>