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(AliasDefinition* node) {}
-  virtual void Visit(VariableDefinition* node) {}
+  virtual void Visit(AliasDefinitionStatement* node) {}
+  virtual void Visit(VariableDefinitionStatement* node) {}
   virtual void Visit(FunctionDeclaration* node) {}
-  virtual void Visit(FunctionDefinition* node) {}
-  virtual void Visit(AliasTypeDefinition* node) {}
-  virtual void Visit(TypeDefinition* node) {}
-  virtual void Visit(TypeclassDefinition* node) {}
+  virtual void Visit(FunctionDefinitionStatement* node) {}
+  virtual void Visit(TypeDefinitionStatement* node) {}
+  virtual void Visit(AbstractTypeDefinitionStatement* 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(DefinedAnnotatedName* node) {}
-  virtual void Visit(DefinedType* node) {}
-  virtual void Visit(DefinedTypeclass* node) {}
+  virtual void Visit(FunctionDefinition* node) {}
+  virtual void Visit(TypeDefinition* 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(ScopedStatement* node) {}
+  virtual void Visit(BlockStatement& node); // variant
 
-  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