abstract type graph added to symbol table

include/find_symbols_visitor.hpp

@@ -11,7 +11,8 @@ namespace interpreter {
 
 class FindSymbolsVisitor : public Visitor {
 public:
-  explicit FindSymbolsVisitor(info::GlobalInfo& global_info) : global_info_(global_info) {}
+  explicit FindSymbolsVisitor(info::GlobalInfo& global_info)
+    : namespace_visitor_(global_info.CreateVisitor()) {}
 
 private:
    // Sources -----------------
@@ -112,7 +113,8 @@ private:
   // // void Visit(CharLiteral* node) override;
 
 private:
-  info::GlobalInfo& global_info_;
+  info::GlobalInfo::NamespaceVisitor namespace_visitor_;
+
   bool is_in_statement = false;
   std::any current_info_;
 };

include/global_info.hpp

@@ -6,6 +6,7 @@
 
 // for clangd
 #include "symbols_info.hpp"
+#include "type_graph.hpp"
 #include "utils.hpp"
 
 namespace info {
@@ -54,6 +55,14 @@ public:
 
     std::optional<utils::IdType> FindTypeclass(const std::optional<std::vector<std::string>>& path,
                                                const std::string typeclass);
+
+    NamespaceVisitor CreateVisitor() {
+      return global_info_.CreateVisitor();
+    }
+
+    TypeGraph* GetAbstractTypeGraph() {
+      return global_info_.GetAbstractTypeGraph();
+    }
   private:
     NamespaceVisitor(GlobalInfo& global_info) : global_info_(global_info),
                                                 namespace_stack_({&global_info.global_namespace_}) {}
@@ -74,6 +83,10 @@ public:
     return NamespaceVisitor(*this);
   }
 
+  TypeGraph* GetAbstractTypeGraph() {
+    return &abstract_type_graph_;
+  }
+
   // TODO: remember about vector realloc
   FunctionInfo* GetFunctionInfo(utils::IdType id) {
     return &functions_[id];
@@ -94,6 +107,8 @@ private:
   std::vector<TypeInfo> types_;
   std::vector<TypeclassInfo> typeclasses_;
 
+  info::TypeGraph abstract_type_graph_;
+
   NamespaceInfo global_namespace_;
   std::vector<ImportInfo> imports_;
   std::unordered_map<std::string, ImportInfo> usages_;

include/interpreter_tree.hpp

@@ -6,6 +6,9 @@
 #include <optional>
 #include <memory>
 
+// for clangd
+#include "utils.hpp"
+
 namespace interpreter::tokens {
 
 // ----------------- Declarations -----------------
@@ -293,6 +296,8 @@ struct AliasDefinitionStatement {
   TypeIdentifier type;
   std::vector<AbstractTypeIdentifier> parameters;
   std::unique_ptr<ParametrizedType> value;
+
+  utils::IdType type_id_;
 };
 
 struct VariableDefinitionStatement {
@@ -306,28 +311,38 @@ struct FunctionDeclaration {
   NameOrOperatorIdentifier name;
   std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
   std::unique_ptr<FunctionType> type;
+
+  utils::IdType function_id_;
 };
 
 struct FunctionDefinitionStatement {
   bool is_inline;
   std::unique_ptr<FunctionDefinition> definition;
   SuperExpression value;
+
+  utils::IdType function_id_;
 };
 
 struct TypeDefinitionStatement {
   enum { Struct, Class } modifier;
   std::unique_ptr<TypeDefinition> definition;
   AnyType value;
+
+  utils::IdType type_id_;
 };
 
 struct AbstractTypeDefinitionStatement {
   enum { Basic, Abstract } modifier;
   std::unique_ptr<AnnotatedType> type;
+
+  utils::IdType type_id_;
 };
 
 struct TypeclassDefinitionStatement {
   std::unique_ptr<TypeDefinition> definition;
   std::vector<std::unique_ptr<FunctionDeclaration>> requirements;
+
+  utils::IdType typeclass_id_;
 };
 
 // Definition parts -----------------

include/link_symbols_visitor.hpp

@@ -0,0 +1,117 @@
+#pragma once
+
+#include <ostream>
+
+// for clangd
+#include "visitor.hpp"
+
+
+namespace interpreter {
+
+// TODO, (maybe add VisitSourceFile?)
+class LinkSymbolsVisitor : public Visitor {
+public:
+  explicit LinkSymbolsVisitor() {}
+
+private:
+  // Sources -----------------
+
+  void Visit(SourceFile* node) override;
+  void Visit(Sources* node) override;
+
+  // Namespaces, partitions -----------------
+
+  void Visit(Partition* 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;
+
+  // Definition parts
+
+  void Visit(FunctionDefinition* node) override;
+  void Visit(TypeDefinition* node) override;
+  void Visit(AnyAnnotatedType* node) override;
+
+  // Flow control -----------------
+
+  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(BinaryOperatorExpression* node) override;
+  void Visit(UnaryOperatorExpression* node) override;
+  void Visit(ReferenceExpression* 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(TypeConstructor* node) override;
+  void Visit(LambdaFunction* node) override;
+  void Visit(ArrayExpression* node) override;
+
+  void Visit(LoopControlExpression& node) override; // enum
+
+  // Name
+
+  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(ParametrizedType* node) override;
+  void Visit(TypeExpression* node) override;
+
+  void Visit(ExtendedScopedAnyType* node) override;
+
+  // Typeclass
+
+  void Visit(ParametrizedTypeclass* node) override;
+  void Visit(TypeclassExpression* node) override;
+
+  // Identifiers, constants, etc. -----------------
+
+  void Visit(ExtendedName* node) override;
+
+  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;
+
+private:
+};
+
+} // namespace interpreter

include/type_check_visitor.hpp

@@ -5,15 +5,12 @@
 #include "symbols_info.hpp"
 #include "visitor.hpp"
 #include "global_info.hpp"
-#include "type_graph.hpp"
 
 namespace interpreter {
 
 class TypeCheckVisitor : public Visitor {
 public:
-  explicit TypeCheckVisitor(info::GlobalInfo& global_info,
-                            info::TypeGraph& type_graph)
-  : global_info_(global_info), type_graph_(type_graph) {}
+  explicit TypeCheckVisitor(info::GlobalInfo& global_info) : global_info_(global_info) {}
 
 private:
   // Sources -----------------
@@ -115,7 +112,6 @@ private:
 
 private:
   info::GlobalInfo& global_info_;
-  info::TypeGraph type_graph_;
   info::TypeInfoContextManager context_manager_;
 
   info::TypeInfo current_type_;