visitor base fixed

include/interpreter_tree.hpp

@@ -369,7 +369,7 @@ struct TypeDefinition {
 
 struct AnnotatedAbstractType {
   AbstractTypeIdentifier type;
-  std::vector<TypeclassExpression> typeclasses;
+  std::vector<std::unique_ptr<TypeclassExpression>> typeclasses;
 
   utils::IdType type_graph_id_;
 };
@@ -459,7 +459,8 @@ struct AccessExpression {
 // Other Expressions -----------------
 
 struct FunctionCallExpression {
-  std::unique_ptr<std::variant<SubExpressionToken, TypeExpression>> prefix;
+  std::variant<std::unique_ptr<SubExpressionToken>,
+               std::unique_ptr<TypeExpression>> prefix;
   ExtendedName name;
   std::vector<FunctionArgument> arguments;
 };
@@ -547,22 +548,22 @@ struct ExtendedScopedAnyType {
 // Typeclass -----------------
 
 struct TypeclassExpression {
-    std::vector<TypeSubExpression> namespaces;
+    std::vector<TypeSubExpression> types;
     TypeclassSubExpression typeclass;
 
     utils::IdType type_id_;
 };
 
 struct ParametrizedTypeclass {
-    TypeclassIdentifier typeclass_expression;
+    TypeclassIdentifier typeclass;
-    std::vector<TypeExpression> parameters;
+    std::vector<std::unique_ptr<TypeExpression>> parameters;
 };
 
 // Typeclass & Type -----------------
 
 struct ParametrizedType {
-  AnyTypeIdentifier type_expression;
+  AnyTypeIdentifier type;
-  std::vector<TypeExpression> parameters;
+  std::vector<std::unique_ptr<TypeExpression>> parameters;
 };
 
 // ----------------- Comments [IGNORE] -----------------

include/visitor.hpp

@@ -45,6 +45,7 @@ protected:
 
   // Flow control -----------------
 
+  virtual void Visit(TypeConstructorPattern* node);
   virtual void Visit(MatchCase* node);
   virtual void Visit(Match* node);
   virtual void Visit(Condition* node);
@@ -53,6 +54,8 @@ 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
 
   // Statements, expressions, blocks, etc. -----------------
@@ -107,7 +110,6 @@ protected:
   virtual void Visit(FunctionType* node);
   virtual void Visit(TupleType* node);
   virtual void Visit(VariantType* node);
-  virtual void Visit(ParametrizedType* node);
   virtual void Visit(TypeExpression* node);
 
   virtual void Visit(AnyType& node); // variant
@@ -116,14 +118,15 @@ protected:
 
   // Typeclass
 
-  virtual void Visit(ParametrizedTypeclass* node);
   virtual void Visit(TypeclassExpression* node);
+  virtual void Visit(ParametrizedTypeclass* node);
 
-  virtual void Visit(TypeclassUsage& node); // variant
+  virtual void Visit(TypeclassSubExpression& node); // variant
 
   // Typeclass & Type
 
-  virtual void Visit(TypeParameter& node); // variant
+  virtual void Visit(ParametrizedType* node);
+
   virtual void Visit(TypeSubExpression& node); // variant
 
   // Identifiers, constants, etc. -----------------

src/visitor.cpp

@@ -39,6 +39,37 @@ void Visitor::Visit(SourceStatement& node) {
 
 // Flow control -----------------
 
+void Visitor::Visit(PatternToken& node) {
+  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());
+      break;
+    case 2:
+      Visit(std::get<std::unique_ptr<TypeConstructorPattern>>(node).get());
+      break;
+    default:
+      // error
+      break;
+  }
+}
+
+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:
@@ -121,9 +152,6 @@ void Visitor::Visit(SubExpression& node) {
       Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node));
       break;
     case 3:
-      Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
-      break;
-    case 4:
       Visit(std::get<std::unique_ptr<ReferenceExpression>>(node).get());
       break;
     default:
@@ -184,6 +212,9 @@ void Visitor::Visit(SuperExpression& node) {
       Visit(std::get<std::unique_ptr<VariantExpression>>(node).get());
       break;
     case 3:
+      Visit(std::get<std::unique_ptr<ArrayExpression>>(node).get());
+      break;
+    case 4:
       Visit(*std::get<std::unique_ptr<Expression>>(node));
       break;
     default:
@@ -234,7 +265,7 @@ void Visitor::Visit(AnyName& node) {
 void Visitor::Visit(AnyType& node) {
   switch (node.index()) {
     case 0:
-      Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
+      Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
       break;
     case 1:
       Visit(std::get<std::unique_ptr<TupleType>>(node).get());
@@ -253,10 +284,10 @@ void Visitor::Visit(AnyType& node) {
 
 // Typeclass
 
-void Visitor::Visit(TypeclassUsage& node) {
+void Visitor::Visit(TypeclassSubExpression& node) {
   switch (node.index()) {
     case 0:
-      Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
+      Visit(std::get<std::unique_ptr<TypeclassIdentifier>>(node).get());
       break;
     case 1:
       Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
@@ -269,20 +300,6 @@ void Visitor::Visit(TypeclassUsage& node) {
 
 // Typeclass & Type
 
-void Visitor::Visit(TypeParameter& node) {
-  switch (node.index()) {
-    case 0:
-      Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
-      break;
-    case 1:
-      Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
 void Visitor::Visit(TypeSubExpression& node) {
   switch (node.index()) {
     case 0:
@@ -425,12 +442,15 @@ void Visitor::Visit(TypeDefinition* node) {
 void Visitor::Visit(AnyAnnotatedType* node) {
   Visit(&node->type);
   for (auto& typeclass : node->typeclasses) {
-    Visit(typeclass);
+    Visit(typeclass.get());
   }
 }
 
 // Flow control -----------------
 
+void Visitor::Visit(TypeConstructorPattern* node) {
+}
+
 void Visitor::Visit(MatchCase* node) {
   Visit(node->value);
   if (node->condition.has_value()) {
@@ -516,7 +536,15 @@ void Visitor::Visit(AccessExpression* node) {
 // Other Expressions
 
 void Visitor::Visit(FunctionCallExpression* node) {
-  Visit(node->name.get());
+  if (std::holds_alternative<std::unique_ptr<SubExpressionToken>>(node->prefix)) {
+    Visit(*std::get<std::unique_ptr<SubExpressionToken>>(node->prefix));
+  } else if (std::holds_alternative<std::unique_ptr<TypeExpression>>(node->prefix)) {
+    Visit(std::get<std::unique_ptr<TypeExpression>>(node->prefix).get());
+  } else {
+    // error
+  }
+
+  Visit(&node->name);
   for (auto& argument : node->arguments) {
     Visit(argument);
   }
@@ -539,10 +567,12 @@ void Visitor::Visit(ReturnExpression* node) {
 }
 
 void Visitor::Visit(TypeConstructor* node) {
-  Visit(node->type.get());
+  Visit(node->constructor.get());
   for (auto& parameter : node->parameters) {
-    Visit(&std::get<0>(parameter));
+    if (parameter.first.has_value()) {
-    Visit(std::get<2>(parameter));
+      Visit(&parameter.first.value().first);
+    }
+    Visit(parameter.second);
   }
 }
 
@@ -565,11 +595,8 @@ void Visitor::Visit(ArrayExpression* node) {
 // Name
 
 void Visitor::Visit(NameExpression* node) {
-  for (auto& variable_namespace : node->namespaces) {
+  for (auto& name : node->names) {
-    Visit(variable_namespace);
+    Visit(&name);
-  }
-  for (size_t i = 0; i < node->expressions.size(); ++i) {
-    Visit(&node->expressions[i]);
   }
 }
 
@@ -629,18 +656,10 @@ void Visitor::Visit(VariantType* node) {
   }
 }
 
-void Visitor::Visit(ParametrizedType* node) {
-  Visit(node->type_expression.get());
-  for (auto& parameter : node->parameters) {
-    Visit(parameter);
-  }
-}
-
 void Visitor::Visit(TypeExpression* node) {
-  for (auto& type_namespace : node->namespaces) {
+  for (auto& type : node->types) {
-    Visit(type_namespace);
+    Visit(type);
   }
-  Visit(&node->type);
 }
 
 void Visitor::Visit(ExtendedScopedAnyType* node) {
@@ -649,18 +668,27 @@ void Visitor::Visit(ExtendedScopedAnyType* node) {
 
 // Typeclass
 
+void Visitor::Visit(TypeclassExpression* node) {
+  for (auto& type : node->types) {
+    Visit(type);
+  }
+  Visit(node->typeclass);
+}
+
 void Visitor::Visit(ParametrizedTypeclass* node) {
-  Visit(node->typeclass_expression.get());
+  Visit(&node->typeclass);
   for (auto& parameter : node->parameters) {
-    Visit(parameter);
+    Visit(parameter.get());
   }
 }
 
-void Visitor::Visit(TypeclassExpression* node) {
+// Typeclass & Type -----------------
-  for (auto& typeclass_namespace : node->namespaces) {
+
-    Visit(typeclass_namespace);
+void Visitor::Visit(ParametrizedType* node) {
+  Visit(&node->type);
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
   }
-  Visit(&node->typeclass);
 }
 
 // Identifiers, constants, etc. -----------------