grammar refactoring: base visitor class fixed

include/interpreter_tree.hpp

@@ -6,10 +6,6 @@
 #include <optional>
 #include <memory>
 
-// for clangd
-#include "node.hpp"
-
-
 namespace interpreter::tokens {
 
 // ----------------- Declarations -----------------
@@ -84,66 +80,51 @@ using FlowControl = std::variant<
 struct Block;
 
 //
-
 struct NameExpression;
 struct ScopedStatement;
-
 using SubExpressionToken = std::variant<
   std::unique_ptr<NameExpression>,
   std::unique_ptr<ScopedStatement>>;
-
 //
-
 struct FunctionCallExpression;
 struct BinaryOperatorExpression;
 struct ArrayExpression;
 struct ReferenceExpression;
-
 using SubExpression = std::variant<
   std::unique_ptr<FunctionCallExpression>,
   std::unique_ptr<BinaryOperatorExpression>,
   std::unique_ptr<SubExpressionToken>,
   std::unique_ptr<ArrayExpression>,
   std::unique_ptr<ReferenceExpression>>;
-
 //
-
 enum class LoopControlExpression {
     Break,
     Continue,
 };
-
+//
 struct ReturnExpression;
-
 using PrefixedExpression = std::variant<
   std::unique_ptr<ReturnExpression>,
   std::unique_ptr<LoopControlExpression>,
   std::unique_ptr<Block>>;
-
 //
-
 struct LambdaFunction;
 struct TypeConstructor;
 struct UnaryOperatorExpression;
-
 using Expression = std::variant<
   std::unique_ptr<LambdaFunction>,
   std::unique_ptr<TypeConstructor>,
   std::unique_ptr<PrefixedExpression>,
   std::unique_ptr<UnaryOperatorExpression>,
   std::unique_ptr<SubExpression>>;
-
 //
-
 struct TupleExpression;
 struct VariantExpression;
-
 using SuperExpression = std::variant<
   std::unique_ptr<FlowControl>,
   std::unique_ptr<TupleExpression>,
   std::unique_ptr<VariantExpression>,
   std::unique_ptr<Expression>>;
-
 //
 
 struct ScopedStatement;
@@ -158,15 +139,16 @@ struct ReferenceExpression;
 
 struct FunctionCallExpression;
 
+//
 struct TypeExpression;
 using FunctionArgument = std::variant<
   SubExpressionToken,
   std::unique_ptr<TypeExpression>>;
+//
 
 struct TupleExpression;
 struct VariantExpression;
 struct ReturnExpression;
-
 struct TypeConstructor;
 struct LambdaFunction;
 struct ArrayExpression;
@@ -429,7 +411,7 @@ struct UnaryOperatorExpression {
 struct ReferenceExpression {
   std::vector<ReferenceType> references;
   ScopedStatement expression;
-}
+};
 
 // Simple Expressions -----------------
 
@@ -522,7 +504,7 @@ struct TypeExpression {
 struct ExtendedScopedAnyType {
   std::vector<ReferenceType> references;
   AnyType type;
-}
+};
 
 // Typeclass -----------------
 

include/visitor.hpp

@@ -14,8 +14,6 @@ public:
   }
 
 protected:
-  virtual void Visit(Node* node) {}
-
   // Sources -----------------
 
   virtual void Visit(SourceFile* node) {}
@@ -29,28 +27,21 @@ protected:
   // Definitions -----------------
 
   virtual void Visit(ImportStatement* node) {}
-  virtual void Visit(UsageDefinition* node) {}
+  virtual void Visit(AliasDefinitionStatement* node) {}
-  virtual void Visit(AliasDefinition* node) {}
+  virtual void Visit(VariableDefinitionStatement* node) {}
-  virtual void Visit(VariableDefinition* node) {}
   virtual void Visit(FunctionDeclaration* node) {}
-  virtual void Visit(FunctionDefinition* node) {}
+  virtual void Visit(FunctionDefinitionStatement* node) {}
-  virtual void Visit(AliasTypeDefinition* node) {}
+  virtual void Visit(TypeDefinitionStatement* node) {}
-  virtual void Visit(TypeDefinition* node) {}
+  virtual void Visit(AbstractTypeDefinitionStatement* node) {}
-  virtual void Visit(TypeclassDefinition* node) {}
+  virtual void Visit(TypeclassDefinitionStatement* node) {}
 
   virtual void Visit(SourceStatement& node); // variant
-  virtual void Visit(ImportSymbol& node); // variant
 
   // Definition parts
 
-  virtual void Visit(DefinedName* node) {}
+  virtual void Visit(FunctionDefinition* node) {}
-  virtual void Visit(DefinedAnnotatedName* node) {}
+  virtual void Visit(TypeDefinition* node) {}
-  virtual void Visit(DefinedType* node) {}
-  virtual void Visit(DefinedTypeclass* node) {}
   virtual void Visit(DefinitionParameter* node) {}
-  virtual void Visit(DefinitionArgument* node) {}
-
-  virtual void Visit(FunctionDeclarationType& node); // variant
 
   // Flow control -----------------
 
@@ -66,10 +57,9 @@ protected:
 
   // Statements, expressions, blocks, etc. -----------------
 
-  virtual void Visit(Block* node) {}
+  virtual void Visit(BlockStatement& node); // variant
-  virtual void Visit(ScopedStatement* node) {}
 
-  virtual void Visit(LoopControlExpression& node) {} // enum
+  virtual void Visit(Block* node) {}
 
   virtual void Visit(SubExpressionToken& node); // variant
   virtual void Visit(SubExpression& node); // variant
@@ -77,29 +67,31 @@ protected:
   virtual void Visit(Expression& node); // variant
   virtual void Visit(SuperExpression& node); // variant
 
-  virtual void Visit(BlockStatement& node); // variant
+  virtual void Visit(ScopedStatement* node) {}
 
   // Operators
 
   virtual void Visit(BinaryOperatorExpression* node) {}
   virtual void Visit(UnaryOperatorExpression* node) {}
+  virtual void Visit(ReferenceExpression* node) {}
 
   // Simple Expressions
 
   virtual void Visit(FunctionCallExpression* node) {}
-  virtual void Visit(TupleExpression* node) {}
-  virtual void Visit(VariantExpression* node) {}
-  virtual void Visit(ReturnExpression* node) {}
 
   virtual void Visit(FunctionArgument& node); // variant
 
-  // Lambda
+  virtual void Visit(TupleExpression* node) {}
-
+  virtual void Visit(VariantExpression* node) {}
+  virtual void Visit(ReturnExpression* node) {}
+  virtual void Visit(TypeConstructor* node) {}
   virtual void Visit(LambdaFunction* node) {}
+  virtual void Visit(ArrayExpression* node) {}
+
+  virtual void Visit(LoopControlExpression& node) {} // enum
 
   // Name
 
-  virtual void Visit(NameSuperExpression* node) {}
   virtual void Visit(NameExpression* node) {}
   virtual void Visit(TupleName* node) {}
   virtual void Visit(VariantName* node) {}
@@ -107,9 +99,11 @@ protected:
 
   virtual void Visit(AnyName& node); // variant
 
+  // Type, typeclass, etc. -----------------
+
   // Type
 
-  virtual void Visit(TypeConstructor* node) {}
+  virtual void Visit(FunctionType* node) {}
   virtual void Visit(TupleType* node) {}
   virtual void Visit(VariantType* node) {}
   virtual void Visit(AnnotatedType* node) {}
@@ -117,16 +111,21 @@ protected:
   virtual void Visit(TypeExpression* node) {}
 
   virtual void Visit(AnyType& node); // variant
-  virtual void Visit(TypeSubExpression& node); // variant
 
-  virtual void Visit(TypeParameter& node); // variant
+  virtual void Visit(ExtendedScopedAnyType* node) {}
 
   // Typeclass
 
-  virtual void Visit(AnnotatedTypeclass* node) {}
   virtual void Visit(ParametrizedTypeclass* node) {}
   virtual void Visit(TypeclassExpression* node) {}
 
+  virtual void Visit(TypeclassUsage& node); // variant
+
+  // Typeclass & Type
+
+  virtual void Visit(TypeParameter& node); // variant
+  virtual void Visit(TypeSubExpression& node); // variant
+
   // Identifiers, constants, etc. -----------------
 
   virtual void Visit(AnyIdentifier* node) {} // std::string
@@ -138,7 +137,7 @@ protected:
 
   virtual void Visit(Literal& node); // variant
 
-  virtual void Visit(NameSubSuperExpression& node); // variant
+  virtual void Visit(NameSubExpression& node); // variant
 };
 
 } // namespace interpreter

src/visitor.cpp

@@ -11,30 +11,24 @@ void Visitor::Visit(SourceStatement& node) {
       Visit(std::get<std::unique_ptr<ImportStatement>>(node).get());
       break;
     case 1:
-      Visit(std::get<std::unique_ptr<UsageDefinition>>(node).get());
+      Visit(std::get<std::unique_ptr<AliasDefinitionStatement>>(node).get());
       break;
     case 2:
-      Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
-      break;
-    case 3:
-      Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
-      break;
-    case 4:
       Visit(std::get<std::unique_ptr<FunctionDeclaration>>(node).get());
       break;
+    case 3:
+      Visit(std::get<std::unique_ptr<FunctionDefinitionStatement>>(node).get());
+      break;
+    case 4:
+      Visit(std::get<std::unique_ptr<TypeDefinitionStatement>>(node).get());
+      break;
     case 5:
-      Visit(std::get<std::unique_ptr<FunctionDefinition>>(node).get());
+      Visit(std::get<std::unique_ptr<AbstractTypeDefinitionStatement>>(node).get());
       break;
     case 6:
-      Visit(std::get<std::unique_ptr<AliasTypeDefinition>>(node).get());
+      Visit(std::get<std::unique_ptr<TypeclassDefinitionStatement>>(node).get());
       break;
     case 7:
-      Visit(std::get<std::unique_ptr<TypeDefinition>>(node).get());
-      break;
-    case 8:
-      Visit(std::get<std::unique_ptr<TypeclassDefinition>>(node).get());
-      break;
-    case 9:
       Visit(std::get<std::unique_ptr<Namespace>>(node).get());
       break;
     default:
@@ -43,45 +37,6 @@ void Visitor::Visit(SourceStatement& node) {
   }
 }
 
-void Visitor::Visit(ImportSymbol& node) {
-  switch (node.index()) {
-    case 0:
-      Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
-      break;
-    case 1:
-      Visit(std::get<std::unique_ptr<TypeExpression>>(node).get());
-      break;
-    case 2:
-      Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
-// Definition parts
-
-void Visitor::Visit(FunctionDeclarationType& node) {
-  switch (node.index()) {
-    case 0:
-      Visit(std::get<std::unique_ptr<ParametrizedType>>(node).get());
-      break;
-    case 1:
-      Visit(std::get<std::unique_ptr<TupleType>>(node).get());
-      break;
-    case 2:
-      Visit(std::get<std::unique_ptr<VariantType>>(node).get());
-      break;
-    case 3:
-      Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
 // Flow control -----------------
 
 void Visitor::Visit(FlowControl& node) {
@@ -112,10 +67,32 @@ void Visitor::Visit(FlowControl& node) {
 
 // Statements, expressions, blocks, etc. -----------------
 
+void Visitor::Visit(BlockStatement& node) {
+  switch (node.index()) {
+    case 0:
+      Visit(*std::get<std::unique_ptr<Expression>>(node));
+      break;
+    case 1:
+      Visit(std::get<std::unique_ptr<VariableDefinitionStatement>>(node).get());
+      break;
+    case 2:
+      Visit(*std::get<std::unique_ptr<FlowControl>>(node));
+      break;
+    case 3:
+      Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
+      break;
+    default:
+      // error
+      break;
+  }
+}
+
+//
+
 void Visitor::Visit(SubExpressionToken& node) {
   switch (node.index()) {
     case 0:
-      Visit(std::get<std::unique_ptr<NameSuperExpression>>(node).get());
+      Visit(std::get<std::unique_ptr<NameExpression>>(node).get());
       break;
     case 1:
       Visit(std::get<std::unique_ptr<ScopedStatement>>(node).get());
@@ -137,6 +114,12 @@ void Visitor::Visit(SubExpression& node) {
     case 2:
       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:
       // error
       break;
@@ -203,31 +186,6 @@ void Visitor::Visit(SuperExpression& node) {
   }
 }
 
-//
-
-void Visitor::Visit(BlockStatement& node) {
-  switch (node.index()) {
-    case 0:
-      Visit(*std::get<std::unique_ptr<Expression>>(node));
-      break;
-    case 1:
-      Visit(std::get<std::unique_ptr<AliasDefinition>>(node).get());
-      break;
-    case 2:
-      Visit(std::get<std::unique_ptr<VariableDefinition>>(node).get());
-      break;
-    case 3:
-      Visit(*std::get<std::unique_ptr<FlowControl>>(node));
-      break;
-    case 4:
-      Visit(*std::get<std::unique_ptr<PrefixedExpression>>(node));
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
 // Simple Expressions
 
 void Visitor::Visit(FunctionArgument& node) {
@@ -263,6 +221,8 @@ void Visitor::Visit(AnyName& node) {
   }
 }
 
+// Type, typeclass, etc. -----------------
+
 // Type
 
 void Visitor::Visit(AnyType& node) { // Or ScopedAnyType
@@ -276,6 +236,41 @@ void Visitor::Visit(AnyType& node) { // Or ScopedAnyType
     case 2:
       Visit(std::get<std::unique_ptr<VariantType>>(node).get());
       break;
+    case 3:
+      Visit(std::get<std::unique_ptr<FunctionType>>(node).get());
+      break;
+    default:
+      // error
+      break;
+  }
+}
+
+// Typeclass
+
+void Visitor::Visit(TypeclassUsage& node) {
+  switch (node.index()) {
+    case 0:
+      Visit(std::get<std::unique_ptr<TypeclassExpression>>(node).get());
+      break;
+    case 1:
+      Visit(std::get<std::unique_ptr<ParametrizedTypeclass>>(node).get());
+      break;
+    default:
+      // error
+      break;
+  }
+}
+
+// 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;
@@ -296,25 +291,6 @@ void Visitor::Visit(TypeSubExpression& node) {
   }
 }
 
-//
-
-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;
-    case 2:
-      Visit(*std::get<std::unique_ptr<Expression>>(node));
-      break;
-    default:
-      // error
-      break;
-  }
-}
-
 // Identifiers, constants, etc. -----------------
 
 void Visitor::Visit(Literal& node) {
@@ -339,7 +315,7 @@ void Visitor::Visit(Literal& node) {
 
 //
 
-void Visitor::Visit(NameSubSuperExpression& node) {
+void Visitor::Visit(NameSubExpression& node) {
   switch (node.index()) {
     case 0:
       Visit(std::get<std::unique_ptr<NameIdentifier>>(node).get());