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

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

  virtual void Visit(NamespaceSources* 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(PartitionStatement* node);

  virtual void Visit(NamespaceStatement& node); // variant
  virtual void Visit(SourceStatement& node); // variant

  // Definition parts

  virtual void Visit(FunctionDefinition* node);
  virtual void Visit(TypeDefinition* node);
  virtual void Visit(AnyAnnotatedType* node);

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

  virtual void Visit(TypeConstructorPatternParameter* node);
  virtual void Visit(TypeConstructorPattern* node);
  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(Pattern& node); // variant
  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(ReferenceExpression* node);
  virtual void Visit(AccessExpression* node);

  // Other expressions

  virtual void Visit(FunctionCallExpression* node);

  virtual void Visit(TupleExpression* node);
  virtual void Visit(VariantExpression* node);
  virtual void Visit(ReturnExpression* node);
  virtual void Visit(TypeConstructorParameter* 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(PartitionName* node);
  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(TypeExpression* node);

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

  virtual void Visit(ExtendedScopedAnyType* node);

  // Typeclass

  virtual void Visit(ParametrizedTypeclass* node);

  // Typeclass & Type

  virtual void Visit(ParametrizedType* 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);
  virtual void Visit(UnitLiteral* node);
  virtual void Visit(BoolLiteral* node);

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

} // namespace interpreter