visitor abstract class added

include/interpreter_tree.hpp

@@ -26,7 +26,7 @@ using TypeclassIdentifier = std::string;
 
 // Sources -----------------
 
-struct SourceFile; // TODO partitions
+struct SourceFile;
 struct Sources;
 
 // Namespaces, partittions -----------------
@@ -42,8 +42,8 @@ struct AliasDefinition;
 struct VariableDefinition;
 struct FunctionDeclaration;
 struct FunctionDefinition;
-struct AliasTypeDefinition; // | Parts of type definition
+struct AliasTypeDefinition;
-struct TypeDefinition;      // |
+struct TypeDefinition;
 struct TypeclassDefinition;
 
 using SourceStatement = std::variant<
@@ -81,7 +81,8 @@ struct DefinitionArgument;
 
 struct Match;
 struct Condition;
-struct WhileLoop; // WhileLoop <-> DoWhileLoop
+struct DoWhileLoop;
+struct WhileLoop;
 struct ForLoop;
 struct LoopLoop;
 
@@ -287,7 +288,7 @@ using ImportSymbol = std::variant<
 
 struct ImportStatement : public Node {
   std::string module_name;
-  std::vector<std::unique_ptr<ImportSymbol>> symbols; // TODO parametric import support
+  std::vector<std::unique_ptr<ImportSymbol>> symbols;
 };
 
 struct UsageDefinition : public Node {
@@ -385,7 +386,12 @@ struct Condition : public Node {
   std::vector<std::unique_ptr<Expression>> stetemets; // if, elif, else
 };
 
-struct WhileLoop : public Node { // WhileLoop <-> DoWhileLoop
+struct DoWhileLoop : public Node {
+  std::unique_ptr<Expression> consition;
+  std::unique_ptr<Expression> statement;
+};
+
+struct WhileLoop : public Node {
   std::unique_ptr<Expression> condition;
   std::unique_ptr<Expression> statement;
 };

include/visitor.hpp

@@ -5,12 +5,103 @@
 
 namespace interpreter {
 
+using namespace tokens;
+
 class Visitor {
 public:
   virtual void Visit(Node* node) = 0; // ??
-  //  visit(SomethingNode node)
+
-  // ...
+  // Sources -----------------
-private:
+
+  virtual void Visit(SourceFile* node) = 0;
+  virtual void Visit(Sources* node) = 0;
+
+  // Namespaces, partittions -----------------
+
+  virtual void Visit(Partition* node) = 0;
+  virtual void Visit(Namespace* node) = 0;
+
+  // Definitions -----------------
+
+  virtual void Visit(ImportStatement* node) = 0;
+  virtual void Visit(UsageDefinition* node) = 0;
+  virtual void Visit(AliasDefinition* node) = 0;
+  virtual void Visit(VariableDefinition* node) = 0;
+  virtual void Visit(FunctionDeclaration* node) = 0;
+  virtual void Visit(FunctionDefinition* node) = 0;
+  virtual void Visit(AliasTypeDefinition* node) = 0;
+  virtual void Visit(TypeDefinition* node) = 0;
+  virtual void Visit(TypeclassDefinition* node) = 0;
+
+  // Definition parts
+
+  virtual void Visit(DefinedName* node) = 0;
+  virtual void Visit(DefinedAnnotatedName* node) = 0;
+  virtual void Visit(DefinedType* node) = 0;
+  virtual void Visit(DefinedTypeclass* node) = 0;
+  virtual void Visit(DefinitionParameter* node) = 0;
+  virtual void Visit(DefinitionArgument* node) = 0;
+
+  // Flow control -----------------
+
+  virtual void Visit(Match* node) = 0;
+  virtual void Visit(Condition* node) = 0;
+  virtual void Visit(DoWhileLoop* node) = 0;
+  virtual void Visit(WhileLoop* node) = 0;
+  virtual void Visit(ForLoop* node) = 0;
+  virtual void Visit(LoopLoop* node) = 0;
+
+  // Statements, expressions, blocks, etc. -----------------
+
+  virtual void Visit(Block* node) = 0;
+  virtual void Visit(ScopedStatement* node) = 0;
+
+  // Operators
+
+  virtual void Visit(BinaryOperatorExpression* node) = 0;
+  virtual void Visit(UnaryOperatorExpression* node) = 0;
+
+  // Simple Expressions
+
+  virtual void Visit(FunctionCallExpression* node) = 0;
+  virtual void Visit(TupleExpression* node) = 0;
+  virtual void Visit(VariantExpression* node) = 0;
+  virtual void Visit(ReturnExpression* node) = 0;
+
+  // Lambda
+
+  virtual void Visit(LambdaFunction* node) = 0;
+
+  // Name
+
+  virtual void Visit(NameSuperExpression* node) = 0;
+  virtual void Visit(NameExpression* node) = 0;
+  virtual void Visit(TupleName* node) = 0;
+  virtual void Visit(VariantName* node) = 0;
+  virtual void Visit(AnnotatedName* node) = 0;
+
+  // Type
+
+  virtual void Visit(TypeConstructor* node) = 0;
+  virtual void Visit(TupleType* node) = 0;
+  virtual void Visit(VariantType* node) = 0;
+  virtual void Visit(AnnotatedType* node) = 0;
+  virtual void Visit(ParametrizedType* node) = 0;
+  virtual void Visit(TypeExpression* node) = 0;
+
+  // Typeclass
+
+  virtual void Visit(AnnotatedTypeclass* node) = 0;
+  virtual void Visit(ParametrizedTypeclass* node) = 0;
+  virtual void Visit(TypeclassExpression* node) = 0;
+
+  // Identifiers, constants, etc. -----------------
+
+  virtual void Visit(FloatNumberLiteral* node) = 0;
+  virtual void Visit(NumberLiteral* node) = 0;
+  virtual void Visit(StringLiteral* node) = 0;
+  virtual void Visit(CharLiteral* node) = 0;
 };
 
 } // namespace interpreter
+