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);
  }

protected:
  // Sources -----------------

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

  // Namespaces, partitions -----------------

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

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

  virtual void Visit(ImportStatement* node) {}
  virtual void Visit(AliasDefinitionStatement* node) {}
  virtual void Visit(VariableDefinitionStatement* node) {}
  virtual void Visit(FunctionDeclaration* 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

  // Definition parts

  virtual void Visit(FunctionDefinition* node) {}
  virtual void Visit(TypeDefinition* node) {}
  virtual void Visit(DefinitionParameter* node) {}

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

  virtual void Visit(MatchCase* node) {}
  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) {}

  virtual void Visit(FlowControl& node); // variant

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

  virtual void Visit(BlockStatement& node); // variant

  virtual void Visit(Block* node) {}

  virtual void Visit(SubExpressionToken& node); // variant
  virtual void Visit(SubExpression& node); // variant
  virtual void Visit(PrefixedExpression& node); // variant
  virtual void Visit(Expression& node); // variant
  virtual void Visit(SuperExpression& 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(FunctionArgument& node); // variant

  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(NameExpression* node) {}
  virtual void Visit(TupleName* node) {}
  virtual void Visit(VariantName* node) {}
  virtual void Visit(AnnotatedName* node) {}

  virtual void Visit(AnyName& node); // variant

  // Type, typeclass, etc. -----------------

  // Type

  virtual void Visit(FunctionType* 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) {}

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

  virtual void Visit(ExtendedScopedAnyType* node) {}

  // Typeclass

  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

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

  virtual void Visit(Literal& node); // variant

  virtual void Visit(NameSubExpression& node); // variant
};

} // namespace interpreter