typeclass tree start

include/interpreter_tree.hpp

@@ -14,6 +14,8 @@ namespace interpreter::tokens {
 struct BaseNode {
   std::pair<size_t, size_t> start_position;
   std::pair<size_t, size_t> end_position;
+
+  std::optional<utils::IdType> type_;
 };
 
 // ----------------- Declarations -----------------

include/typeclass_graph.hpp

@@ -1,9 +1,7 @@
 #pragma once
 
+#include <algorithm>
 #include <string>
-////////////////////////////////////////////////////////////////////////////////////////
-// Temporary frozen, TODO
-////////////////////////////////////////////////////////////////////////////////////////
 
 #pragma once
 
@@ -12,41 +10,63 @@
 // for calngd
 #include "utils.hpp"
 #include "interpreter_tree.hpp"
-#include "error_handling.hpp"
 
 namespace info {
 
 class TypeclassGraph {
 public:
-  struct TypeclassMethod {
-    std::string name;
-    interpreter::tokens::FunctionDeclaration* definition = nullptr;
+  struct MethodInfo {
+    interpreter::tokens::FunctionDeclaration* declaration = nullptr;
+    std::optional<interpreter::tokens::FunctionDefinition*> definition;
   };
 
   struct ParametrizedTypeclass {
-    utils::IdType typeclass;
-    std::vector<utils::IdType> parameter_ids; // ??
+    std::string typeclass;
+    // TODO: parameters
   };
 
   struct TypeclassVertex {
-    std::vector<std::pair<std::string, std::vector<ParametrizedTypeclass>>> parameters;
-    std::vector<TypeclassMethod> methods;
-    std::vector<ParametrizedTypeclass> dependencies;
+    std::string name;
     interpreter::tokens::TypeclassDefinitionStatement* definition = nullptr;
+    std::unordered_map<std::string, MethodInfo> methods;
+    std::vector<ParametrizedTypeclass> dependencies;
+
+    // TODO: std::vector<std::pair<std::string, std::vector<ParametrizedTypeclass>>> parameters;
   };
 
-  utils::IdType AddTypeclass(const TypeclassVertex& typeclass) { // TODO: universal reference
-    for (auto& method : typeclass.methods) {
-      if (method_to_typeclass_.count(method.name) != 0) {
-        error_handling::HandleTypecheckError("");
+  std::optional<utils::IdType> AddTypeclass(
+    const std::string& name,
+    interpreter::tokens::TypeclassDefinitionStatement* definition,
+    const std::vector<ParametrizedTypeclass>& dependencies,
+    const std::vector<std::pair<std::string, interpreter::tokens::FunctionDeclaration*>>& method_declarations,
+    const std::vector<std::pair<std::string, interpreter::tokens::FunctionDefinition*>>& method_definitions) {
+    for (auto& method : method_declarations) {
+      if (method_to_typeclass_.count(method.first) != 0) {
+        return std::nullopt;
       }
     }
-    for (auto& method : typeclass.methods) {
-      method_to_typeclass_[method.name] = typeclasses_.size();
+
+    is_calculated_ = false;
+
+    typeclasses_.emplace_back();
+    TypeclassVertex& typeclass = typeclasses_.back();
+    typeclass.name = name;
+    typeclass.definition = definition;
+    typeclass.dependencies = dependencies;
+
+    for (auto& method : method_declarations) {
+      method_to_typeclass_[method.first] = typeclasses_.size();
+      typeclass.methods[method.first].declaration = method.second;
     }
-    typeclasses_.push_back(typeclass);
+    name_to_typeclass_[name] = typeclasses_.size() - 1;
+
+    for (auto& method : method_definitions) {
+      typeclass.methods[method.first].definition = method.second;
+    }
+
     return typeclasses_.size() - 1;
   }
+
   std::optional<utils::IdType> FindMethodTypeclass(const std::string& name) {
     auto method_iter = method_to_typeclass_.find(name);
     if (method_iter == method_to_typeclass_.end()) {
@@ -55,12 +75,62 @@ public:
     return method_iter->second;
   }
 
-  const TypeclassVertex& GetTypeclass(utils::IdType id) {
+  const TypeclassVertex& GetTypeclass(utils::IdType id) { // check, if calculated ??
     return typeclasses_.at(id);
   }
+
+  bool IsCalculated() {
+    return is_calculated_;
+  }
+
+  bool CalculateGraph() {
+    if (is_calculated_) {
+      return true;
+    }
+
+    std::vector<std::vector<size_t>> edges(typeclasses_.size());
+
+    for (size_t i = 0; i < typeclasses_.size(); ++i) {
+      edges[i].resize(typeclasses_[i].dependencies.size());
+      for (size_t j = 0; j < edges[i].size(); ++j) {
+        auto dependency_iter = name_to_typeclass_.find(typeclasses_[i].dependencies[j].typeclass);
+
+        if (dependency_iter == name_to_typeclass_.end()) {
+          return false;
+        }
+
+        edges[i][j] = dependency_iter->second;
+      }
+    }
+
+    std::vector<size_t> sorted_verticles = utils::BackTopSort(edges);
+    std::reverse(sorted_verticles.begin(), sorted_verticles.end());
+
+    for (auto& id : sorted_verticles) {
+      for (auto& dependency : typeclasses_[id].dependencies) {
+        for (auto& method : typeclasses_[name_to_typeclass_[dependency.typeclass]].methods) {
+          auto method_iter = typeclasses_[id].methods.find(method.first);
+          if (method_iter == typeclasses_[id].methods.end()) {
+            typeclasses_[id].methods[method.first] = method.second;
+          } else {
+            if (!method_iter->second.definition.has_value()) {
+              method_iter->second.definition = method.second.definition;
+            }
+          }
+        }
+      }
+    }
+
+    is_calculated_ = true;
+
+    return true;
+  }
 private:
   std::unordered_map<std::string, utils::IdType> method_to_typeclass_;
+  std::unordered_map<std::string, utils::IdType> name_to_typeclass_;
   std::vector<TypeclassVertex> typeclasses_;
+
+  bool is_calculated_ = true;
 };
 
 } // namespace info

include/typed_print_visitor.hpp

@@ -0,0 +1,128 @@
+#pragma once
+
+#include <ostream>
+
+// for clangd
+#include "type_info_contexts.hpp"
+#include "visitor.hpp"
+
+namespace interpreter {
+
+class TypedPrintVisitor : public Visitor {
+public:
+  explicit TypedPrintVisitor(std::ostream& out,
+                             info::TypeInfoContextManager& context_manager)
+    : out_(out), context_manager_(context_manager) {}
+
+private:
+  // Sources -----------------
+
+  void Visit(SourceFile* node) override;
+
+  // Namespaces, partitions -----------------
+
+  void Visit(PartitionSources* node) override;
+  void Visit(Partition* node) override;
+  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;
+
+  // 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(BinaryOperatorExpression* node) override;
+  void Visit(UnaryOperatorExpression* node) override;
+  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(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(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;
+  void Visit(UnitLiteral* node) override;
+
+private:
+  std::ostream& out_;
+  info::TypeInfoContextManager& context_manager_;
+};
+
+} // namespace interpreter

include/types.hpp

@@ -234,6 +234,8 @@ public:
 
   std::optional<utils::IdType> GetFieldType(const std::string& name) const;
 
+  std::string GetTypeName() const;
+
 private:
   std::variant<AbstractType,
                DefinedType,

include/utils.hpp

@@ -107,4 +107,32 @@ private:
   std::vector<size_t> ranks_;
 };
 
+static void BackVisitDfs(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) {
+    BackVisitDfs(id, verticles, marks, edges, mark);
+  }
+}
+
+static std::vector<size_t> BackTopSort(const std::vector<std::vector<size_t>>& edges_) {
+  std::vector<size_t> sorted_verticles;
+  std::vector<size_t> marks(edges_.size(), 0);
+
+  for (size_t i = 0; i < marks.size(); ++i) {
+    BackVisitDfs(i, sorted_verticles, marks, edges_, 1);
+  }
+
+  return sorted_verticles;
+}
+
 } // namespace utils