print & build visitor fixed and tested

include/build_visitor.hpp

@@ -144,6 +144,7 @@ private:
   void Visit(NumberLiteral* node) override;
   void Visit(StringLiteral* node) override;
   void Visit(CharLiteral* node) override;
+  void Visit(UnitLiteral* node) override;
 
   void Visit(Literal& node) override; // variant
 private:

include/find_symbols_visitor.hpp

@@ -44,6 +44,8 @@ private:
 
   // Flow control -----------------
 
+  // // void Visit(TypeConstructorPatternParameter* node) override;
+  // // void Visit(TypeConstructorPattern* node) override;
   // // void Visit(MatchCase* node) override;
   // // void Visit(Match* node) override;
   // // void Visit(Condition* node) override;
@@ -68,14 +70,15 @@ private:
   // Simple Expressions
 
   // // void Visit(FunctionCallExpression* node) override;
-  // //
+
   // // void Visit(TupleExpression* node) override;
   // // void Visit(VariantExpression* node) override;
   // // void Visit(ReturnExpression* node) override;
+  // // void Visit(TypeConstructorParameter* node) override;
   // // void Visit(TypeConstructor* node) override;
   // // void Visit(LambdaFunction* node) override;
   // // void Visit(ArrayExpression* node) override;
-  // //
+
   // // void Visit(LoopControlExpression& node) override; // enum
 
   // Name
@@ -92,26 +95,30 @@ private:
   // // void Visit(FunctionType* node) override;
   // // void Visit(TupleType* node) override;
   // // void Visit(VariantType* node) override;
-  // // void Visit(ParametrizedType* node) override;
   // // void Visit(TypeExpression* node) override;
-  // //
+
   // // void Visit(ExtendedScopedAnyType* node) override;
 
   // Typeclass
 
-  // // void Visit(ParametrizedTypeclass* node) override;
   // // void Visit(TypeclassExpression* node) override;
+  // // void Visit(ParametrizedTypeclass* node) override;
+
+  // Typeclass & Type
+
+  // // void Visit(ParametrizedType* node) override;
 
   // Identifiers, constants, etc. -----------------
 
   // // void Visit(ExtendedName* node) override;
-  // //
+
   // // void Visit(std::string* node) override; // std::string
-  // //
+
   // // void Visit(FloatNumberLiteral* node) override;
   // // void Visit(NumberLiteral* node) override;
   // // void Visit(StringLiteral* node) override;
   // // void Visit(CharLiteral* node) override;
+  // // void Visit(UnitLiteral* node) override;
 
 private:
   info::GlobalInfo::NamespaceVisitor namespace_visitor_;

include/interpreter_tree.hpp

@@ -94,12 +94,14 @@ struct FloatNumberLiteral;
 struct NumberLiteral;
 struct StringLiteral;
 struct CharLiteral;
+struct UnitLiteral;
 
 using Literal = std::variant<
   std::unique_ptr<FloatNumberLiteral>,
   std::unique_ptr<NumberLiteral>,
   std::unique_ptr<StringLiteral>,
-  std::unique_ptr<CharLiteral>>;
+  std::unique_ptr<CharLiteral>,
+  std::unique_ptr<UnitLiteral>>;
 
 //
 struct NameExpression;
@@ -278,10 +280,7 @@ struct Partition {
   enum PartitionName {
     Test,
     Interface,
-    Core,
+    Code,
-    Lib,
-    Module,
-    Exe,
   };
 
   PartitionName name;
@@ -487,7 +486,7 @@ struct TypeConstructorParameter {
   enum AssignmentModifier { Move, Assign };
   std::optional<ExtendedName> name;
   std::optional<AssignmentModifier> asignment_modifier;
-  PatternToken value;
+  SubExpression value;
 };
 
 struct TypeConstructor {
@@ -599,4 +598,6 @@ struct CharLiteral {
   char value;
 };
 
+struct UnitLiteral {};
+
 } // namespace interpereter::tokens

include/link_symbols_visitor.hpp

@@ -45,6 +45,8 @@ private:
 
   // Flow control -----------------
 
+  // // void Visit(TypeConstructorPatternParameter* node) override;
+  // // void Visit(TypeConstructorPattern* node) override;
   // // void Visit(MatchCase* node) override;
   // // void Visit(Match* node) override;
   // // void Visit(Condition* node) override;
@@ -72,6 +74,7 @@ private:
   // // void Visit(TupleExpression* node) override;
   // // void Visit(VariantExpression* node) override;
   // // void Visit(ReturnExpression* node) override;
+  // // void Visit(TypeConstructorParameter* node) override;
   // // void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
   // // void Visit(ArrayExpression* node) override;
@@ -92,15 +95,18 @@ private:
   // // void Visit(FunctionType* node) override;
   // // void Visit(TupleType* node) override;
   // // void Visit(VariantType* node) override;
-  // // void Visit(ParametrizedType* node) override;
+  void Visit(TypeExpression* node) override; // TODO
-  void Visit(TypeExpression* node) override;
 
   // // void Visit(ExtendedScopedAnyType* node) override;
 
   // Typeclass
 
+  void Visit(TypeclassExpression* node) override; // TODO
   // // void Visit(ParametrizedTypeclass* node) override;
-  void Visit(TypeclassExpression* node) override;
+
+  // Typeclass & Type
+
+  // // void Visit(ParametrizedType* node) override;
 
   // Identifiers, constants, etc. -----------------
 

include/parse_token_types.hpp

@@ -129,6 +129,7 @@ const std::string FloatNumberLiteral = "float_number_literal";
 const std::string NumberLiteral = "number_literal";
 const std::string StringLiteral = "string_literal";
 const std::string CharLiteral = "char_literal";
+const std::string UnitLiteral = "unit_literal";
 
 const std::string Literal = "literal";
 

include/print_visitor.hpp

@@ -115,6 +115,7 @@ private:
   void Visit(NumberLiteral* node) override;
   void Visit(StringLiteral* node) override;
   void Visit(CharLiteral* node) override;
+  void Visit(UnitLiteral* node) override;
 
 private:
   std::ostream& out_;

include/type_check_visitor.hpp

@@ -43,6 +43,8 @@ private:
 
   // Flow control -----------------
 
+  void Visit(TypeConstructorPatternParameter* node) override;
+  void Visit(TypeConstructorPattern* node) override;
   void Visit(MatchCase* node) override;
   void Visit(Match* node) override;
   void Visit(Condition* node) override;
@@ -71,6 +73,7 @@ private:
   void Visit(TupleExpression* node) override;
   void Visit(VariantExpression* node) override;
   void Visit(ReturnExpression* node) override;
+  void Visit(TypeConstructorParameter* node) override;
   void Visit(TypeConstructor* node) override;
   void Visit(LambdaFunction* node) override;
   void Visit(ArrayExpression* node) override;
@@ -91,15 +94,18 @@ private:
   void Visit(FunctionType* node) override;
   void Visit(TupleType* node) override;
   void Visit(VariantType* node) override;
-  void Visit(ParametrizedType* node) override;
   void Visit(TypeExpression* node) override;
 
   void Visit(ExtendedScopedAnyType* node) override;
 
   // Typeclass
 
-  void Visit(ParametrizedTypeclass* node) override;
   void Visit(TypeclassExpression* node) override;
+  void Visit(ParametrizedTypeclass* node) override;
+
+  // Typeclass & Type
+
+  void Visit(ParametrizedType* node) override;
 
   // Identifiers, constants, etc. -----------------
 
@@ -111,6 +117,7 @@ private:
   void Visit(NumberLiteral* node) override;
   void Visit(StringLiteral* node) override;
   void Visit(CharLiteral* node) override;
+  void Visit(UnitLiteral* node) override;
 
 private:
   info::GlobalInfo::NamespaceVisitor namespace_visitor_;

include/visitor.hpp

@@ -141,6 +141,7 @@ protected:
   virtual void Visit(NumberLiteral* node);
   virtual void Visit(StringLiteral* node);
   virtual void Visit(CharLiteral* node);
+  virtual void Visit(UnitLiteral* node);
 
   virtual void Visit(Literal& node); // variant
 };

src/build_visitor.cpp

@@ -85,14 +85,8 @@ void BuildVisitor::Visit(Partition* node) {
       node->name = Partition::Test;
   } else if (name == "INTERFACE") {
       node->name = Partition::Interface;
-  } else if (name == "CORE") {
+  } else if (name == "CODE") {
-      node->name = Partition::Core;
+      node->name = Partition::Code;
-  } else if (name == "LIB") {
-      node->name = Partition::Lib;
-  } else if (name == "MODULE") {
-      node->name = Partition::Module;
-  } else if (name == "EXE") {
-      node->name = Partition::Exe;
   }
 
   current_node_ = parse_node.ChildByFieldName("scope");
@@ -198,10 +192,13 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
 
   size_t child_count = parse_node.NamedChildCount();
 
-  for (size_t i = 0; i + 2 < child_count; ++i) {
+  if (child_count > 2) {
-      current_node_ = parse_node.NthNamedChild(i + 1);
+    node->parameters.resize(child_count - 2);
-      node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
+    for (size_t i = 0; i + 2 < child_count; ++i) {
-      Visit(node->parameters.back().get());
+        current_node_ = parse_node.NthNamedChild(i + 1);
+        node->parameters[i] = std::make_unique<AnnotatedAbstractType>();
+        Visit(node->parameters.back().get());
+    }
   }
 
   current_node_ = parse_node.ChildByFieldName("type");
@@ -395,6 +392,7 @@ void BuildVisitor::Visit(AnyAnnotatedType* node) {
 
     for (size_t i = 0; i + 1 < child_count; ++i) {
         current_node_ = parse_node.NthNamedChild(i + 1);
+        node->typeclasses[i] = std::make_unique<TypeclassExpression>();
         Visit(node->typeclasses[i].get());
     }
   }
@@ -871,6 +869,7 @@ void BuildVisitor::Visit(AccessExpression* node) {
   auto parse_node = current_node_;
 
   current_node_ = parse_node.ChildByFieldName("name");
+  node->name = std::make_unique<NameExpression>();
   Visit(node->name.get());
 
   current_node_ = parse_node.ChildByFieldName("id");
@@ -1300,7 +1299,7 @@ void BuildVisitor::Visit(AnyType& node) {
 
   std::string current_node_type = current_node_.GetType();
 
-  if (current_node_type == parser::tokens::ParametrizedType) {
+  if (current_node_type == parser::tokens::TypeExpression) {
     node = std::make_unique<TypeExpression>();
     Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
   } else if (current_node_type == parser::tokens::TupleType) {
@@ -1346,21 +1345,21 @@ void BuildVisitor::Visit(ExtendedScopedAnyType* node) {
 
 void BuildVisitor::Visit(TypeclassExpression* node) {
   auto parse_node = current_node_;
-  //
+
   size_t child_count = parse_node.NamedChildCount();
-  //
+
-  // if (child_count > 1) {
+  if (child_count > 1) {
-  //   node->path.resize(child_count - 1);
+    node->path.resize(child_count - 1);
-  //
+
-  //   for (size_t i = 0; i + 1 < child_count; ++i) {
+    for (size_t i = 0; i + 1 < child_count; ++i) {
-  //       current_node_ = parse_node.NthNamedChild(i);
+        current_node_ = parse_node.NthNamedChild(i);
-  //       Visit(node->path[i]);
+        Visit(node->path[i]);
-  //   }
+    }
-  // }
+  }
-  //
+
   current_node_ = parse_node.ChildByFieldName("typeclass");
   Visit(node->typeclass);
-  //
+
   current_node_ = parse_node;
 }
 
@@ -1482,6 +1481,8 @@ void BuildVisitor::Visit(CharLiteral* node) {
   node->value = literal.substr(1, literal.size() - 2).back(); // TODO: special symbols, etc.
 }
 
+void BuildVisitor::Visit(UnitLiteral* node) {}
+
 void BuildVisitor::Visit(Literal& node) {
   auto parse_node = current_node_;
 
@@ -1501,6 +1502,9 @@ void BuildVisitor::Visit(Literal& node) {
   } else if (current_node_type == parser::tokens::CharLiteral) {
     node = std::make_unique<CharLiteral>();
     Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
+  } else if (current_node_type == parser::tokens::UnitLiteral) {
+    node = std::make_unique<UnitLiteral>();
+    Visit(std::get<std::unique_ptr<UnitLiteral>>(node).get());
   } else {
     // error
   }

src/main.cpp

@@ -33,8 +33,8 @@ int main(int argc, char** argv) { // TODO, only test version
     std::make_unique<interpreter::tokens::SourceFile>();
 
   interpreter::BuildVisitor build_visitor(parse_tree);
-//  interpreter::PrintVisitor print_visitor(std::cout);
+  interpreter::PrintVisitor print_visitor(std::cout);
 
   build_visitor.VisitSourceFile(source_file.get());
-//  print_visitor.VisitSourceFile(source_file.get());
+  print_visitor.VisitSourceFile(source_file.get());
 }

src/print_visitor.cpp

@@ -38,17 +38,8 @@ void PrintVisitor::Visit(Partition* node) {
     case Partition::Interface:
       out_ << "INTERFACE";
       break;
-    case Partition::Core:
+    case Partition::Code:
-      out_ << "CORE";
+      out_ << "CODE";
-      break;
-    case Partition::Lib:
-      out_ << "LIB";
-      break;
-    case Partition::Module:
-      out_ << "MODULE";
-      break;
-    case Partition::Exe:
-      out_ << "EXE";
       break;
   }
   out_ << " {\n";
@@ -281,8 +272,8 @@ void PrintVisitor::Visit(TypeConstructorPattern* node) {
   for (auto& parameter : node->parameters) {
     if (!is_first) {
       out_ << ")\n";
-      is_first = false;
     }
+    is_first = false;
     out_ << '(';
     Visit(&parameter);
   }
@@ -514,8 +505,8 @@ void PrintVisitor::Visit(TypeConstructor* node) {
   for (auto& parameter : node->parameters) {
     if (!is_first) {
       out_ << ")\n";
-      is_first = false;
     }
+    is_first = false;
     out_ << '(';
     Visit(&parameter);
   }
@@ -735,4 +726,8 @@ void PrintVisitor::Visit(CharLiteral* node) {
   out_ << "[Char " << node->value << "] ";
 }
 
+void PrintVisitor::Visit(UnitLiteral* node) {
+  out_ << "[Unit ()] ";
+}
+
 } // namespace interpreter

src/visitor.cpp

@@ -330,6 +330,9 @@ void Visitor::Visit(Literal& node) {
     case 3:
       Visit(std::get<std::unique_ptr<CharLiteral>>(node).get());
       break;
+    case 4:
+      Visit(std::get<std::unique_ptr<UnitLiteral>>(node).get());
+      break;
     default:
       // error
       break;
@@ -723,5 +726,7 @@ void Visitor::Visit(StringLiteral* node) {}
 
 void Visitor::Visit(CharLiteral* node) {}
 
+void Visitor::Visit(UnitLiteral* node) {}
+
 } // namespace interpreter
 

tests/match.lang

@@ -5,7 +5,7 @@ def fruit_cost : fruit = {
 }
 
 def amount_to_string : x is_zero_separated = {
-   const ans = match x with
+  const ans = match x with
      | 0 ? is_zero_separated () -> "Zero"
      | 0 | 1 | 2 | 3 | 4 -> "Few"
      | x ? (5..9).contains x -> "Several"

tests/types.lang

@@ -3,6 +3,6 @@ alias T1 = Int
 abstract (T2 : #A #B #C)
 
 // Used to pre-compile module for some types
-// let T2 = Int
+let T2 = Int
-// let T2 = Float
+let T2 = Float
-// let T2 = Complex
+let T2 = Complex