lang_2023/include/visitor.hpp

#pragma once

// for clangd
#include "interpreter_tree.hpp"

namespace interpreter {

using namespace tokens;

class Visitor {
public:
  virtual void VisitSourceFile(SourceFile* source_file) {
    Visit(source_file);
  }

  // -----------------

  virtual void Visit(Node* node) {}

  // Sources -----------------

  virtual void Visit(SourceFile* node) {}
  virtual void Visit(Sources* node) {}

  // Namespaces, partittions -----------------

  virtual void Visit(Partition* node) {}
  virtual void Visit(Namespace* node) {}

  // Definitions -----------------

  virtual void Visit(ImportStatement* node) {}
  virtual void Visit(UsageDefinition* node) {}
  virtual void Visit(AliasDefinition* node) {}
  virtual void Visit(VariableDefinition* 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) {}

  void Visit(SourceStatement& node); // variant
  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(DefinitionParameter* node) {}
  virtual void Visit(DefinitionArgument* node) {}

  void Visit(FunctionDeclarationType& node); // variant

  // Flow control -----------------

  virtual void Visit(Match* node) {}
  virtual void Visit(Condition* node) {}
  virtual void Visit(DoWhileLoop* node) {}
  virtual void Visit(WhileLoop* node) {}
  virtual void Visit(ForLoop* node) {}
  virtual void Visit(LoopLoop* node) {}

  void Visit(FlowControl& node); // variant

  // Statements, expressions, blocks, etc. -----------------

  virtual void Visit(Block* node) {}
  virtual void Visit(ScopedStatement* node) {}

  virtual void Visit(LoopControlExpression& node) {} // enum

  void Visit(SubExpressionToken& node); // variant
  void Visit(SubExpression& node); // variant
  void Visit(PrefixedExpression& node); // variant
  void Visit(Expression& node); // variant
  void Visit(SuperExpression& node); // variant

  void Visit(BlockStatement& node); // variant

  // Operators

  virtual void Visit(BinaryOperatorExpression* node) {}
  virtual void Visit(UnaryOperatorExpression* node) {}

  // Simple Expressions

  virtual void Visit(FunctionCallExpression* node) {}
  virtual void Visit(TupleExpression* node) {}
  virtual void Visit(VariantExpression* node) {}
  virtual void Visit(ReturnExpression* node) {}

  void Visit(FunctionArgument& node); // variant

  // Lambda

  virtual void Visit(LambdaFunction* node) {}

  // Name

  virtual void Visit(NameSuperExpression* node) {}
  virtual void Visit(NameExpression* node) {}
  virtual void Visit(TupleName* node) {}
  virtual void Visit(VariantName* node) {}
  virtual void Visit(AnnotatedName* node) {}

  void Visit(AnyName& node); // variant

  // Type

  virtual void Visit(TypeConstructor* node) {}
  virtual void Visit(TupleType* node) {}
  virtual void Visit(VariantType* node) {}
  virtual void Visit(AnnotatedType* node) {}
  virtual void Visit(ParametrizedType* node) {}
  virtual void Visit(TypeExpression* node) {}

  void Visit(AnyType& node); // variant
  void Visit(TypeSubExpression& node); // variant

  void Visit(TypeParameter& node); // variant

  // Typeclass

  virtual void Visit(AnnotatedTypeclass* node) {}
  virtual void Visit(ParametrizedTypeclass* node) {}
  virtual void Visit(TypeclassExpression* node) {}

  // Identifiers, constants, etc. -----------------

  virtual void Visit(AnyIdentifier* node) {} // std::string

  virtual void Visit(FloatNumberLiteral* node) {}
  virtual void Visit(NumberLiteral* node) {}
  virtual void Visit(StringLiteral* node) {}
  virtual void Visit(CharLiteral* node) {}

  void Visit(Literal& node); // variant

  void Visit(NameSubSuperExpression& node); // variant
};

} // namespace interpreter