fixes , constructor patter fix, for loop fix

include/build_visitor.hpp

@@ -61,7 +61,6 @@ private:
   void Visit(ForLoop* node) override;
   void Visit(LoopLoop* node) override;
 
-  void Visit(PatternToken& node) override; // variant
   void Visit(Pattern& node) override; // variant
   void Visit(FlowControl& node) override; // variant
 

include/interpreter_tree.hpp

@@ -246,15 +246,13 @@ struct ExtendedName {
   std::string name;
 };
 
-using PatternToken = std::variant<
+using Pattern = std::variant<
   std::unique_ptr<ExtendedName>,
   std::unique_ptr<Literal>,
   std::unique_ptr<TypeConstructorPattern>>;
 
 
-using Pattern = std::variant<
-  std::unique_ptr<TypeConstructorPattern>,
-  std::unique_ptr<PatternToken>>;
+using ScopedPattern = Pattern;
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -413,7 +411,7 @@ struct TypeConstructorPatternParameter {
   BaseNode base;
 
   std::optional<ExtendedName> name;
-  PatternToken value;
+  ScopedPattern value;
 };
 
 struct TypeConstructorPattern {
@@ -462,6 +460,7 @@ struct WhileLoop {
 struct ForLoop {
   BaseNode base;
 
+  utils::IsConstModifier variable_modifier;
   AnyName variable;
   Expression interval;
   Expression statement;

include/visitor.hpp

@@ -58,7 +58,6 @@ protected:
   virtual void Visit(ForLoop* node);
   virtual void Visit(LoopLoop* node);
 
-  virtual void Visit(PatternToken& node); // variant
   virtual void Visit(Pattern& node); // variant
   virtual void Visit(FlowControl& node); // variant
 

src/build_visitor.cpp

@@ -504,7 +504,7 @@ void BuildVisitor::Visit(TypeConstructorPattern* node) {
 }
 
 
-void BuildVisitor::Visit(PatternToken& node) {
+void BuildVisitor::Visit(Pattern& node) { // <-> ScopedPattern
   auto parse_node = current_node_;
 
   current_node_ = parse_node.NthNamedChild(0);
@@ -527,26 +527,6 @@ void BuildVisitor::Visit(PatternToken& node) {
   current_node_ = parse_node;
 }
 
-void BuildVisitor::Visit(Pattern& node) {
-  auto parse_node = current_node_;
-
-  current_node_ = parse_node.NthNamedChild(0);
-
-  std::string current_node_type = current_node_.GetType();
-
-  if (current_node_type == parser::tokens::TypeConstructorPattern) { // optimize ??
-    node = std::make_unique<TypeConstructorPattern>();
-    Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
-  } else if (current_node_type == parser::tokens::PatternToken) {
-    node = std::make_unique<PatternToken>();
-    Visit(*std::get<std::unique_ptr<PatternToken>>(node));
-  } else {
-    // error
-  }
-
-  current_node_ = parse_node;
-}
-
 void BuildVisitor::Visit(MatchCase* node) {
   SetPosition(node->base, current_node_);
 
@@ -653,6 +633,13 @@ void BuildVisitor::Visit(ForLoop* node) {
 
   auto parse_node = current_node_;
 
+  std::string modifier = parse_node.NthChild(1).GetValue();
+  if (modifier == "const") {
+    node->variable_modifier = utils::IsConstModifier::Const;
+  } else if (modifier == "var") {
+    node->variable_modifier = utils::IsConstModifier::Var;
+  }
+
   current_node_ = parse_node.ChildByFieldName("variable");
   Visit(node->variable);
 

src/print_visitor.cpp

@@ -331,7 +331,16 @@ void PrintVisitor::Visit(WhileLoop* node) {
   out_ << ")\n";
 }
 void PrintVisitor::Visit(ForLoop* node) {
-  out_ << "[For] (";
+  out_ << "[For ";
+  switch (node->variable_modifier) {
+    case utils::IsConstModifier::Const:
+      out_ << "const";
+      break;
+    case utils::IsConstModifier::Var:
+      out_ << "var";
+      break;
+  }
+  out_ << "] (";
   Visitor::Visit(node->variable);
   out_ << ") [in] (";
   Visitor::Visit(node->interval);

src/type_check_visitor.cpp

@@ -319,16 +319,19 @@ void TypeCheckVisitor::Visit(MatchCase* node) {
   is_const_definition_ = true; // TODO: or var??
   Visitor::Visit(node->value);
 
+  utils::IdType value_type = current_type_;
+
   switch (node->value.index()) {
     case 0:
-      context_manager_.DefineVariable(std::get<0>(node->value)->name,
+      context_manager_.DefineVariable(std::get<std::unique_ptr<ExtendedName>>(node->value)->name,
                                       current_type_,
                                       is_const_definition_.value());
       break;
     case 1:
-
-      Visitor::Visit(*std::get<1>(node->value).get());
-
+      Visitor::Visit(*std::get<std::unique_ptr<Literal>>(node->value));
+      if (context_manager_.EqualTypes(current_type_, value_type)) {
+        error_handling::HandleTypecheckError("Literal and value have different types", node->base);
+      }
       break;
     case 2:
       Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node->value).get());
@@ -452,7 +455,9 @@ void TypeCheckVisitor::Visit(ForLoop* node) {
   }
 
   current_type_ = context_manager_.AddType(maybe_interval_type.value()->GetElementsType());
+  is_const_definition_ = (node->modifier == utils::IsConstModifier::Const);
   Visitor::Visit(node->variable); // type passed to variable definition throught current_type_
+  is_const_definition_ = std::nullopt;
 
   Visitor::Visit(node->statement);
 

src/visitor.cpp

@@ -64,13 +64,13 @@ void Visitor::Visit(SourceStatement& node) {
 
 // Flow control -----------------
 
-void Visitor::Visit(PatternToken& node) {
+void Visitor::Visit(Pattern& node) { // <-> ScopedPattern
   switch (node.index()) {
     case 0:
       Visit(std::get<std::unique_ptr<ExtendedName>>(node).get());
       break;
     case 1:
-      Visit(*std::get<std::unique_ptr<Literal>>(node).get());
+      Visit(*std::get<std::unique_ptr<Literal>>(node));
       break;
     case 2:
       Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
@@ -81,20 +81,6 @@ void Visitor::Visit(PatternToken& node) {
   }
 }
 
-void Visitor::Visit(Pattern& node) {
-  switch (node.index()) {
-    case 0:
-      Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
-      break;
-    case 1:
-      Visit(*std::get<std::unique_ptr<PatternToken>>(node));
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
 void Visitor::Visit(FlowControl& node) {
   switch (node.index()) {
     case 0: