type graph class

include/find_symbols_visitor.hpp

@@ -7,10 +7,6 @@
 #include "visitor.hpp"
 #include "global_info.hpp"
 
-// TODO:
-// add/remove global variables
-//
-
 namespace interpreter {
 
 class FindSymbolsVisitor : public Visitor {

include/global_info.hpp

@@ -12,7 +12,7 @@ namespace info {
 class GlobalInfo {
 public:
   GlobalInfo() {
-    namespace_stack.push_back(&global_namespace_);
+    namespace_stack_.push_back(&global_namespace_);
   }
 
   void AddImport(ImportInfo&& import_info, const std::optional<std::string>& name = std::nullopt) {
@@ -23,62 +23,80 @@ public:
     }
   }
 
-  void AddEnterNamespace(const std::string& type,
+  void AddEnterNamespace(const std::string& name,
                          const std::optional<NamespaceInfo::Modifier>& modifier = std::nullopt,
                          const std::optional<std::string>& variable = std::nullopt) {
-    NamespaceInfo* namespace_info = &namespace_stack.back()->namespaces[type].emplace_back();
-    namespace_stack.push_back(namespace_info);
+    NamespaceInfo* namespace_info = &namespace_stack_.back()->namespaces[name].emplace_back();
+    namespace_stack_.push_back(namespace_info);
 
     namespace_info->modifier = modifier;
     namespace_info->variable = variable;
-    namespace_info->type_name = type;
+    namespace_info->type_name = name;
+  }
+
+  void EnterNamespace(const std::string& name) { // TODO: enter sibling namespace, etc.
+    auto& namespace_parts = namespace_stack_.back()->namespaces[name];
+    for (auto& part : namespace_parts) {
+      if (part.variable == std::nullopt) {
+        namespace_stack_.push_back(&part);
+      }
+    }
+  }
+
+  void ExitAllNameNamespaces(const std::string& name) {
+    while(namespace_stack_.size() > 1 && namespace_stack_.back()->type_name == name) {
+      namespace_stack_.pop_back();
+    }
   }
 
   void ExitNamespace() {
-    if (namespace_stack.size() <= 1) {
+    if (namespace_stack_.size() <= 1) {
       // error
       return;
     }
 
-    namespace_stack.pop_back();
+    namespace_stack_.pop_back();
   }
 
   void ToGlobalNamespace() {
-    namespace_stack.clear();
-    namespace_stack.push_back(&global_namespace_);
+    namespace_stack_.clear();
+    namespace_stack_.push_back(&global_namespace_);
   }
 
   void AddFunctionDeclaration(const std::string& name,
                               FunctionDeclarationInfo&& function_declaration_info) {
-    FunctionInfo* function_info = &namespace_stack.back()->functions[name];
+    FunctionInfo* function_info = &namespace_stack_.back()->functions[name];
 
     function_info->declaration = std::move(function_declaration_info);
   }
 
   void AddFunctionDefinition(const std::string& name,
                    FunctionDefinitionInfo&& function_definition_info) {
-    FunctionInfo* function_info = &namespace_stack.back()->functions[name];
+    FunctionInfo* function_info = &namespace_stack_.back()->functions[name];
 
     function_info->definition = std::move(function_definition_info);
   }
 
   void AddType(const std::string& type,
                TypeInfo&& type_info) {
-    namespace_stack.back()->types[type] = std::move(type_info);
+    namespace_stack_.back()->types[type] = std::move(type_info);
   }
 
   void AddTypeclass(const std::string& typeclass,
                     TypeclassInfo&& typeclass_info) {
-    namespace_stack.back()->typeclasses[typeclass] = std::move(typeclass_info);
+    namespace_stack_.back()->typeclasses[typeclass] = std::move(typeclass_info);
   }
 
-  // FindFunction
-  // FindType
+  void FindFunction(const std::vector<std::string>& path) {
+    // TODO
+  }
 
-  // FindVar ??
+  void FindType(const std::vector<std::string>& path) {
+    // TODO
+  }
 
 private:
-  std::vector<NamespaceInfo*> namespace_stack;
+  std::vector<NamespaceInfo*> namespace_stack_;
 
   NamespaceInfo global_namespace_;
   std::vector<ImportInfo> imports_;

include/type_check_visitor.hpp

@@ -0,0 +1,115 @@
+#pragma once
+
+// for clangd
+#include "visitor.hpp"
+#include "global_info.hpp"
+
+namespace interpreter {
+
+class TypeCheckVisitor : public Visitor {
+public:
+  explicit TypeCheckVisitor(info::GlobalInfo& global_info) : global_info_(global_info) {}
+
+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:
+  info::GlobalInfo& global_info_;
+};
+
+} // namespace interpreter

include/type_graph.hpp

@@ -0,0 +1,239 @@
+#include <vector>
+#include <unordered_set>
+#include <unordered_map>
+#include <optional>
+#include <string>
+
+// TODO: optimize recalc
+
+class TypeGraph {
+public:
+  size_t AddVertex(const std::vector<std::string>& path,
+                   const std::vector<std::string>& methods = {},
+                   const std::vector<std::string>& typeclasses = {}) {
+    is_calculated_ = false;
+
+    Vertex vertex;
+    vertex.path = path;
+
+    for (auto& method : methods) {
+      vertex.new_requirements.methods.insert(GetHash(method));
+    }
+
+    for (auto& typeclass : typeclasses) {
+      vertex.new_requirements.typeclasses.insert(GetHash(typeclass));
+    }
+
+    verticles_.push_back(vertex);
+    edges_.emplace_back();
+    back_edges_.emplace_back();
+
+    verticle_ids_[vertex.path] = verticles_.size() - 1;
+    return verticles_.size() - 1;
+  }
+
+  size_t FindVertex(const std::vector<std::string>& path) {
+    return verticle_ids_[path];
+  }
+
+  std::vector<std::string> VertexMethods(size_t id) {
+    if (!is_calculated_) {
+      // error
+      return {};
+    }
+
+    size_t cluster_id = verticles_[id].cluster.value();
+
+    std::vector<std::string> methods;
+
+    methods.reserve(cluster_requirements_[cluster_id].methods.size());
+
+    for (auto& method : cluster_requirements_[cluster_id].methods) {
+      methods.push_back(std::move(GetString(method)));
+    }
+
+    return methods;
+  }
+
+  std::vector<std::string> VertexTypeclasses(size_t id) {
+    if (!is_calculated_) {
+      // error
+      return {};
+    }
+
+    size_t cluster_id = verticles_[id].cluster.value();
+
+    std::vector<std::string> typeclasses;
+
+    typeclasses.reserve(cluster_requirements_[cluster_id].typeclasses.size());
+
+    for (auto& typeclass : cluster_requirements_[cluster_id].typeclasses) {
+      typeclasses.push_back(std::move(GetString(typeclass)));
+    }
+
+    return typeclasses;
+  }
+
+  void AddTypeclass(size_t id, const std::string& method) {
+    is_calculated_ = false;
+
+    verticles_[id].new_requirements.methods.insert(GetHash(method));
+  }
+
+  void AddMethod(size_t id, const std::string& typeclass) {
+    is_calculated_ = false;
+
+    verticles_[id].new_requirements.typeclasses.insert(GetHash(typeclass));
+  }
+
+  void AddEdge(size_t from, size_t to) {
+    is_calculated_ = false;
+
+    edges_[from].push_back(to);
+    back_edges_[to].push_back(from);
+  }
+
+  void Calculate() {
+    if (is_calculated_) {
+      return;
+    }
+
+    auto clusters = FindClusters();
+
+    std::vector<RequirementsData> cluster_requirements(clusters.size());
+    std::vector<std::unordered_set<size_t>> cluster_edges(clusters.size());
+
+    for (size_t i = 0; i < clusters.size(); ++i) {
+      for (auto& vertex_id : clusters[i]) {
+        for (auto& method : verticles_[vertex_id].new_requirements.methods) {
+          cluster_requirements[i].methods.insert(method);
+        }
+        verticles_[vertex_id].new_requirements.methods.clear();
+
+        for (auto& typeclass : verticles_[vertex_id].new_requirements.typeclasses) {
+          cluster_requirements[i].typeclasses.insert(typeclass);
+        }
+        verticles_[vertex_id].new_requirements.methods.clear();
+
+        for (auto& edge : edges_[vertex_id]) {
+          cluster_edges[i].insert(edge);
+        }
+      }
+    }
+
+    // TODO: check, that clusters are top sorted
+    for (size_t i = 0; i < clusters.size(); ++i) {
+      for (auto& edge : cluster_edges[i]) {
+        for (auto& method : cluster_requirements[edge].methods) {
+          cluster_requirements[i].methods.insert(method);
+        }
+
+        for (auto& typeclass : cluster_requirements[edge].typeclasses) {
+          cluster_requirements[i].typeclasses.insert(typeclass);
+        }
+      }
+    }
+
+    for (size_t i = 0; i < clusters.size(); ++i) {
+      for (auto& vertex_id : clusters[i]) {
+        verticles_[vertex_id].cluster = i;
+      }
+    }
+
+    clusters_ = std::move(clusters);
+    cluster_requirements_ = std::move(cluster_requirements);
+
+    is_calculated_ = true;
+  }
+
+
+
+private:
+  struct RequirementsData {
+    std::unordered_set<size_t> methods;
+    std::unordered_set<size_t> typeclasses;
+  };
+
+  struct Vertex {
+    std::vector<std::string> path;
+    RequirementsData new_requirements;
+    std::optional<size_t> cluster;
+  };
+
+  std::vector<std::vector<size_t>> FindClusters() {
+    std::vector<std::vector<size_t>> clusters;
+
+    auto sorted_verticles = TopSort();
+
+    std::vector<size_t> marks(sorted_verticles.size(), 0);
+    for (size_t i = 0; i < sorted_verticles.size(); ++i) {
+      if (marks[i] == 0) {
+        clusters.emplace_back();
+        VisitDfs(i, clusters[i], marks, back_edges_, clusters.size());
+      }
+    }
+
+    return clusters;
+  }
+
+  void VisitDfs(size_t id,
+                std::vector<size_t>& verticles,
+                std::vector<size_t>& marks,
+                const std::vector<std::vector<size_t>>& edges,
+                size_t mark) {
+    if (marks[id] != 0) {
+      return;
+    }
+
+    marks[id] = mark;
+    verticles.push_back(id);
+
+    for (size_t i = 0; i < edges[id].size(); ++i) {
+      VisitDfs(id, verticles, marks, edges, mark);
+    }
+  }
+
+  std::vector<size_t> TopSort() {
+    std::vector<size_t> sorted_verticles;
+    std::vector<size_t> marks(verticles_.size(), 0);
+
+    for (size_t i = 0; i < marks.size(); ++i) {
+      VisitDfs(i, sorted_verticles, marks, edges_, 1);
+    }
+
+    return sorted_verticles;
+  }
+
+  size_t GetHash(const std::string& str) {
+    size_t hash = 0;
+    auto str_position = string_to_hash_.find(str);
+
+    if (str_position == string_to_hash_.end()) {
+      hash = hash_to_string_.size();
+      string_to_hash_[str] = hash;
+      hash_to_string_.push_back(str);
+    } else {
+      hash = str_position->second;
+    }
+
+    return hash;
+  }
+
+  std::string GetString(size_t hash) {
+    return hash_to_string_[hash];
+  }
+
+private:
+  std::unordered_map<std::vector<std::string>, size_t> verticle_ids_;
+  std::vector<std::vector<size_t>> edges_;
+  std::vector<std::vector<size_t>> back_edges_;
+  std::vector<Vertex> verticles_;
+
+  std::vector<std::vector<size_t>> clusters_;
+  std::vector<RequirementsData> cluster_requirements_;
+
+  std::vector<std::string> hash_to_string_;
+  std::unordered_map<std::string, size_t> string_to_hash_;
+
+  bool is_calculated_ = false;
+};