lang_2023/include/build_visitor.hpp

#pragma once

// for clangd
#include "visitor.hpp"
#include "parse_tree.hpp"

namespace interpreter {

class BuildVisitor : public Visitor {
public:
  BuildVisitor(const parser::ParseTree& parse_tree) : parse_tree_(parse_tree) {}

  void VisitSourceFile(SourceFile* source_file) override {
    current_node_ = parse_tree_.GetRoot();
    Visit(source_file);
  }

private:
  void Visit(Node* node) override;

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

  void Visit(SourceFile* node) override;
  void Visit(Sources* node) override;

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

  void Visit(Partition* node) override;
  void Visit(Namespace* node) override;

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

  void Visit(ImportStatement* node) override;
  void Visit(UsageDefinition* node) override;
  void Visit(AliasDefinition* node) override;
  void Visit(VariableDefinition* node) override;
  void Visit(FunctionDeclaration* node) override;
  void Visit(FunctionDefinition* node) override;
  void Visit(AliasTypeDefinition* node) override;
  void Visit(TypeDefinition* node) override;
  void Visit(TypeclassDefinition* node) override;

  void Visit(SourceStatement& node) override; // variant
  void Visit(ImportSymbol& node) override; // variant

  // Definition parts

  void Visit(DefinedName* node) override;
  void Visit(DefinedAnnotatedName* node) override;
  void Visit(DefinedType* node) override;
  void Visit(DefinedTypeclass* node) override;
  void Visit(DefinitionParameter* node) override;
  void Visit(DefinitionArgument* node) override;

  void Visit(FunctionDeclarationType& node) override; // variant

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

  void Visit(Match* node) override;
  void Visit(Condition* node) override;
  void Visit(DoWhileLoop* node) override;
  void Visit(WhileLoop* node) override;
  void Visit(ForLoop* node) override;
  void Visit(LoopLoop* node) override;

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

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

  void Visit(Block* node) override;
  void Visit(ScopedStatement* node) override;

  void Visit(LoopControlExpression& node) override; // enum

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

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

  // Operators

  void Visit(BinaryOperatorExpression* node) override;
  void Visit(UnaryOperatorExpression* node) override;

  // Simple Expressions

  void Visit(FunctionCallExpression* node) override;
  void Visit(TupleExpression* node) override;
  void Visit(VariantExpression* node) override;
  void Visit(ReturnExpression* node) override;

  void Visit(FunctionArgument& node) override; // variant

  // Lambda

  void Visit(LambdaFunction* node) override;

  // Name

  void Visit(NameSuperExpression* node) override;
  void Visit(NameExpression* node) override;
  void Visit(TupleName* node) override;
  void Visit(VariantName* node) override;
  void Visit(AnnotatedName* node) override;

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

  // Type

  void Visit(TypeConstructor* node) override;
  void Visit(TupleType* node) override;
  void Visit(VariantType* node) override;
  void Visit(AnnotatedType* node) override;
  void Visit(ParametrizedType* node) override;
  void Visit(TypeExpression* node) override;

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

  void Visit(TypeParameter& node) override; // variant

  // Typeclass

  void Visit(AnnotatedTypeclass* node) override;
  void Visit(ParametrizedTypeclass* node) override;
  void Visit(TypeclassExpression* node) override;

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

  void Visit(AnyIdentifier* node) override; // std::string

  void Visit(FloatNumberLiteral* node) override;
  void Visit(NumberLiteral* node) override;
  void Visit(StringLiteral* node) override;
  void Visit(CharLiteral* node) override;

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

  void Visit(NameSubSuperExpression& node) override; // variant
private:
  const parser::ParseTree& parse_tree_;
  parser::ParseTree::Node current_node_;
};

} // namespace interpreter