st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2025-12-07 15:38:47 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

part of typeclass_graph

Browse source
This commit is contained in:
ProgramSnail 2023-05-14 13:05:46 +03:00
parent 4f54bb4bd7
commit 9aeba7b0de
8 changed files with 154 additions and 68 deletions
Download patch file Download diff file Expand all files Collapse all files

82
src/global_info.cpp
View file

@ -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