lang_2023/include/execute_visitor.hpp

#pragma once

#include <ostream>

// for clangd
#include "contexts.hpp"
#include "global_info.hpp"
#include "interpreter_tree.hpp"
#include "types.hpp"
#include "utils.hpp"
#include "values.hpp"
#include "visitor.hpp"
#include "error_handling.hpp"

namespace interpreter {

class ExecuteVisitor : public Visitor {
public:
  explicit ExecuteVisitor(info::GlobalInfo& global_info,
                          info::ContextManager<info::type::Type, info::type::TypeManager>& type_context_manager,
                          info::ContextManager<info::value::Value, info::value::ValueManager>& context_manager)
    : global_info_(global_info),
      typeclass_graph_(*global_info.GetTypeclassGraph()),
      type_context_manager_(type_context_manager),
      context_manager_(context_manager) {}

  void VisitSourceFile(SourceFile* node) override {
    error_handling::HandleInternalError("VisitSourceFile unavailible",
                                        "ExecuteVisitor.VisitSourceFile",
                                        &node->base);
  };

  void ExecutePartition(interpreter::tokens::PartitionStatement* partition) {
    for (size_t i = 0; i < info::type::InternalTypesCount; ++i) {
      info::type::InternalType type = static_cast<info::type::InternalType>(i);
      std::string type_name = info::type::ToString(type);
      context_manager_.DefineLocalType(type_name, global_info_.FindAbstractType(type_name).value()->node->type->graph_id_);
    }
    Visit(partition);
  }

private:
  // Sources -----------------

  void Visit(SourceFile* node) override;

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

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

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

  void Visit(ImportStatement* node) override;
  void Visit(AliasDefinitionStatement* node) override;
  void Visit(VariableDefinitionStatement* node) override;
  void Visit(FunctionDeclaration* node) override;
  void Visit(FunctionDefinitionStatement* node) override;
  void Visit(TypeDefinitionStatement* node) override;
  void Visit(AbstractTypeDefinitionStatement* node) override;
  void Visit(TypeclassDefinitionStatement* node) override;
  void Visit(PartitionStatement* node) override;

  // Definition parts

  // // void Visit(FunctionDefinition* node) override;
  // // void Visit(TypeDefinition* node) override;
  // // void Visit(AnyAnnotatedType* node) override;

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

  void Visit(TypeConstructorPatternParameter* node) override;
  void Visit(TypeConstructorPattern* node) override;
  void Visit(MatchCase* node) override;
  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;

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

  void Visit(Block* node) override;

  void Visit(ScopedStatement* node) override;

  // Operators

  void Visit(ReferenceExpression* node) override;
  void Visit(AccessExpression* 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(TypeConstructorParameter* node) override;
  void Visit(TypeConstructor* node) override;
  void Visit(LambdaFunction* node) override;
  void Visit(ArrayExpression* node) override;

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

  // Name

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

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

  // Type

  void Visit(FunctionType* node) override;
  void Visit(TupleType* node) override;
  void Visit(VariantType* node) override;
  void Visit(TypeExpression* node) override;

  void Visit(ExtendedScopedAnyType* node) override;

  // Typeclass

  void Visit(ParametrizedTypeclass* node) override;

  // Typeclass & Type

  void Visit(ParametrizedType* node) override;

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

  // // void Visit(std::string* 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(UnitLiteral* node) override;
  void Visit(BoolLiteral* node) override;

  bool HandleCondition(Expression& condition, const BaseNode& base_node);
  void CollectTypeContext(const ParametrizedType& type);
  void CheckPattern(Pattern& node, const BaseNode& base_node);

  template<typename T>
  T* ExtractValue(utils::IdType value, const BaseNode& base_node) {
    std::optional<T*> maybe_value_info = context_manager_.GetValue<T>(value);
    if (!maybe_value_info.has_value()) {
      error_handling::HandleRuntimeError("Value has value class that is different from exprected one", base_node);
    }
    return maybe_value_info.value();
  }

  template<typename T>
  T* ExtractInternalValue(utils::IdType value, const BaseNode& base_node) {
    info::value::InternalValue* value_info = ExtractValue<info::value::InternalValue>(value, base_node);
    std::optional<T*> maybe_internal_value_info = value_info->GetValue<T>();
    if (!maybe_internal_value_info.has_value()) {
      error_handling::HandleRuntimeError("Value has internal value class that is different from exprected one", base_node);
    }
    return maybe_internal_value_info.value();
  }

  utils::IdType GraphIdByTypeId(utils::IdType type_id) {
    auto maybe_any_type = global_info_.GetTypeInfo<info::definition::AnyType>(type_id);
    if (!maybe_any_type.has_value()) {
      error_handling::HandleInternalError("Only AnyType implemented",
                                          "ExecuteVisitor.ExtractInternalValue",
                                          std::nullopt);
    }
    return maybe_any_type.value()->node->definition->type->graph_id_;
  }

  //

  bool HandleBuiltinFunctionCall(FunctionCallExpression* node);

  bool HandleBuiltinTypeFunctionCall(FunctionCallExpression* node,
                                     info::type::InternalType type);
private:
  info::GlobalInfo& global_info_;
  info::TypeclassGraph& typeclass_graph_;
  info::ContextManager<info::type::Type, info::type::TypeManager>& type_context_manager_;

  info::ContextManager<info::value::Value, info::value::ValueManager>& context_manager_;
  // local types store types graph ids

  utils::IdType current_value_;
  std::optional<LoopControlExpression> active_loop_control_expression_;
  std::optional<utils::IsConstModifier> is_const_definition_;
  bool case_matched_;
};

} // namespace interpreter