grammar refactoring: base visitor class fixed

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