part of typeclass_graph

src/find_symbols_visitor.cpp

@@ -10,7 +10,7 @@ namespace interpreter {
 // Namespaces, partitions -----------------
 
 void FindSymbolsVisitor::Visit(Namespace* node) {
-   namespace_visitor_.AddEnterNamespace(node->type, node->modifier, node->base);
+  namespace_visitor_.AddEnterNamespace(node->type, node->modifier, node, node->base);
 
   Visitor::Visit(&node->scope);
 
@@ -44,6 +44,11 @@ void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
 }
 
 void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
+  info::definition::Namespace* current_namespace = namespace_visitor_.GetCurrentNamespace();
+  if (current_namespace->node.has_value() && current_namespace->node.value()->link_typeclass_id_.has_value()) {
+    error_handling::HandleTypecheckError("Can't declare typeclass methods not as requirements", node->base);
+  }
+
   info::definition::FunctionDeclaration info;
 
   info.parameters.resize(node->parameters.size());
@@ -97,7 +102,7 @@ void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
   }
 
   any_type_info.value = &node->value;
-  any_type_info.parent_namespace = namespace_visitor_.GetCurrentNamespace();
+  any_type_info.parent_namespace = namespace_visitor_.GetCurrentNamespaceId();
   any_type_info.modifier = node->modifier;
 
   std::string type = any_type_info.type.type;
@@ -136,12 +141,13 @@ void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
   }
 
   for (size_t i = 0; i < node->requirements.size(); ++i) {
-    namespace_visitor_.AddEnterNamespace(type_name, node->requirements[i].first, node->base);
+    namespace_visitor_.AddEnterNamespace(type_name, node->requirements[i].first, std::nullopt, node->base);
     Visit(node->requirements[i].second.get());
     namespace_visitor_.ExitNamespace();
   }
 
   info.node = node;
+  info.parent_namespace = namespace_visitor_.GetCurrentNamespaceId();
 
   node->typeclass_id_ = namespace_visitor_.AddTypeclass(type_name, std::move(info), node->base);
 }

src/global_info.cpp

@@ -19,6 +19,7 @@ void GlobalInfo::NamespaceVisitor::AddImport(definition::Import&& import_info,
 
 void GlobalInfo::NamespaceVisitor::AddEnterNamespace(const std::string& name,
                                                      utils::ClassInternalsModifier modifier,
+                                                     std::optional<interpreter::tokens::Namespace*> node,
                                                      const interpreter::tokens::BaseNode& base_node) {
   if (type::ToInternalType(name).has_value()) {
     error_handling::HandleTypecheckError("Can't define basic type namespace", base_node);
@@ -33,15 +34,14 @@ void GlobalInfo::NamespaceVisitor::AddEnterNamespace(const std::string& name,
     id = global_info_.namespaces_.size();
     (*current_namespaces)[name] = id;
     global_info_.namespaces_.emplace_back();
+
+    global_info_.namespaces_.back().modifier = modifier;
+    global_info_.namespaces_.back().node = node;
   } else {
     id = namespace_iter->second;
   }
   definition::Namespace* namespace_info = &global_info_.namespaces_[id];
 
-  if (modifier != utils::ClassInternalsModifier::Static) {
-    namespace_info->modifier = modifier;
-  }
-
   namespace_info->parent_namespace = namespace_stack_.back();
 
   namespace_info->type_name = name;
@@ -464,4 +464,78 @@ std::unordered_map<std::string, utils::IdType>*
   return current_namespaces;
 }
 
+//
+
+std::optional<utils::IdType> GlobalInfo::AddTypeclassToGraph(utils::IdType typeclass) {
+  definition::Typeclass* typeclass_info = &GetTypeclassInfo(typeclass);
+  definition::Namespace* parent_namespace = &GetNamespaceInfo(typeclass_info->parent_namespace);
+
+  std::string name = typeclass_info->node->definition->type->type;
+  std::vector<TypeclassGraph::ParametrizedTypeclass> dependencies;
+  std::vector<std::pair<std::string, std::pair<utils::ClassInternalsModifier, interpreter::tokens::FunctionDeclaration*>>> function_declarations;
+  std::vector<std::pair<std::string, interpreter::tokens::FunctionDefinitionStatement*>> function_definitions;
+
+  for (auto& dependency_node : typeclass_info->node->definition->type->typeclasses) {
+    TypeclassGraph::ParametrizedTypeclass dependency;
+    dependency.typeclass = dependency_node->typeclass;
+    if (dependency_node->parameters.size() > 0) {
+      error_handling::HandleInternalError("Paramtrized typeclass requirements are not implemented yet",
+                                          "TypeclassGraph.AddTypeclassByNode");
+    }
+    dependencies.push_back(dependency);
+  }
+
+  auto namespace_iter = parent_namespace->namespaces.find(name);
+  if (namespace_iter != parent_namespace->namespaces.end()) {
+    CollectFunctionInfo(namespace_iter->second,
+                        utils::ClassInternalsModifier::Static,
+                        function_declarations,
+                        function_definitions);
+  }
+
+  auto const_namespace_iter = parent_namespace->const_namespaces.find(name);
+  if (namespace_iter != parent_namespace->const_namespaces.end()) {
+    CollectFunctionInfo(namespace_iter->second,
+                        utils::ClassInternalsModifier::Const,
+                        function_declarations,
+                        function_definitions);
+  }
+
+  auto var_namespace_iter = parent_namespace->var_namespaces.find(name);
+  if (namespace_iter != parent_namespace->var_namespaces.end()) {
+    CollectFunctionInfo(namespace_iter->second,
+                        utils::ClassInternalsModifier::Var,
+                        function_declarations,
+                        function_definitions);
+  }
+
+  // TODO
+
+  return typeclass_graph_.AddTypeclass(name,
+                                       typeclass_info->node,
+                                       dependencies,
+                                       function_declarations,
+                                       function_definitions);
+}
+
+void GlobalInfo::CollectFunctionInfo(
+    utils::IdType current_namespace,
+    utils::ClassInternalsModifier modifier,
+    std::vector<std::pair<std::string, std::pair<utils::ClassInternalsModifier, interpreter::tokens::FunctionDeclaration*>>>& function_declarations,
+    std::vector<std::pair<std::string, interpreter::tokens::FunctionDefinitionStatement*>>& function_definitions) {
+  for (auto& function : GetNamespaceInfo(current_namespace).functions) {
+    definition::Function function_info = GetFunctionInfo(function.second);
+
+    if (function_info.declaration.has_value()) {
+      function_declarations.push_back(
+        {function.first,
+          {modifier, function_info.declaration.value().node}});
+    }
+
+    if (function_info.definition.has_value()) {
+      function_definitions.push_back({function.first, function_info.definition.value().node});
+    }
+  }
+}
+
 } // namespace info

src/link_symbols_visitor.cpp

@@ -37,6 +37,18 @@ void LinkSymbolsVisitor::Visit(Namespace* node) {
   namespace_visitor_.ExitNamespace();
 }
 
+// Definitions -----------------
+
+// TODO: add to typeclass graph, etc. (+ check)
+void LinkSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
+  Visitor::Visit(node->definition.get());
+  for (auto& function_requirement : node->requirements) {
+    Visitor::Visit(function_requirement.second.get());
+  }
+
+  namespace_visitor_.GetGlobalInfo()->AddTypeclassToGraph(node->typeclass_id_);
+}
+
 // Type, typeclass, etc. -----------------
 
 // Type