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

adding types to typeclass tree, part 1

Browse source
This commit is contained in:
ProgramSnail 2023-05-19 11:55:46 +03:00
parent 17328b842c
commit d841e2754b
7 changed files with 260 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

182
src/global_info.cpp
View file

@ -460,79 +460,79 @@ std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindNamespaceIn(
//
// cache ??
std::unordered_set<utils::IdType>
GlobalInfo::GetAnnotatedTypeTypeclassesSet(interpreter::tokens::AnnotatedType* node) {
std::unordered_set<utils::IdType> typeclasses;
for (auto& typeclass : node->typeclasses) {
utils::IdType graph_id = typeclasses_[typeclass->typeclass_id_].graph_id_;
std::vector<utils::IdType> dependencies = typeclass_graph_.GetTypeclassDependencies(graph_id);
for (auto& dependency : dependencies) {
typeclasses.insert(dependency);
}
typeclasses.insert(graph_id);
}
return typeclasses;
}
std::vector<utils::IdType>
GlobalInfo::GetAnnotatedTypeTypeclassesVector(interpreter::tokens::AnnotatedType* node) {
std::unordered_set<utils::IdType> typeclasses_set = GetAnnotatedTypeTypeclassesSet(node);
std::vector<utils::IdType> typeclasses_vector;
typeclasses_vector.reserve(typeclasses_vector.size());
for (auto& typeclass : typeclasses_set) {
typeclasses_vector.push_back(typeclass);
}
return typeclasses_vector;
}
std::unordered_map<std::string, TypeclassGraph::FunctionInfo> // TODO: optimize, cache
GlobalInfo::GetAnnotatedTypeFunctionsMap(interpreter::tokens::AnnotatedType* node,
const interpreter::tokens::BaseNode& base_node) {
std::unordered_map<std::string, TypeclassGraph::FunctionInfo> functions;
for (auto& typeclass : node->typeclasses) {
utils::IdType graph_id = typeclasses_[typeclass->typeclass_id_].graph_id_;
auto requirements = typeclass_graph_.GetTypeclassFunctions(graph_id);
for (auto& requirement : requirements) {
auto requirement_iter = functions.find(requirement.first);
if (requirement_iter == functions.end()) {
functions[requirement.first] = *requirement.second;
} else {
if (requirement_iter->second.definition.has_value()) {
if (requirement.second->definition.has_value()) {
error_handling::HandleTypecheckError("Function defined more then in one type requirement", base_node);
}
} else {
requirement_iter->second.definition = requirement.second->definition;
}
}
}
}
return functions;
}
std::vector<std::pair<std::string, TypeclassGraph::FunctionInfo>> // TODO: optimize, cache
GlobalInfo::GetAnnotatedTypeFunctionsVector(interpreter::tokens::AnnotatedType* node,
const interpreter::tokens::BaseNode& base_node) {
auto functions_set = GetAnnotatedTypeFunctionsMap(node, base_node);
std::vector<std::pair<std::string, TypeclassGraph::FunctionInfo>> functions_vector;
functions_vector.reserve(functions_vector.size());
for (auto& typeclass : functions_set) {
functions_vector.push_back(typeclass);
}
return functions_vector;
}
// // cache ??
// std::unordered_set<utils::IdType>
// GlobalInfo::GetAnnotatedTypeTypeclassesSet(interpreter::tokens::AnnotatedType* node) {
//
// std::unordered_set<utils::IdType> typeclasses;
//
// for (auto& typeclass : node->typeclasses) {
// utils::IdType graph_id = typeclasses_[typeclass->typeclass_id_].graph_id_;
//
// std::vector<utils::IdType> dependencies = typeclass_graph_.GetTypeclassDependencies(graph_id);
// for (auto& dependency : dependencies) {
// typeclasses.insert(dependency);
// }
//
// typeclasses.insert(graph_id);
// }
// return typeclasses;
// }
//
// std::vector<utils::IdType>
// GlobalInfo::GetAnnotatedTypeTypeclassesVector(interpreter::tokens::AnnotatedType* node) {
//
// std::unordered_set<utils::IdType> typeclasses_set = GetAnnotatedTypeTypeclassesSet(node);
//
// std::vector<utils::IdType> typeclasses_vector;
// typeclasses_vector.reserve(typeclasses_vector.size());
// for (auto& typeclass : typeclasses_set) {
// typeclasses_vector.push_back(typeclass);
// }
// return typeclasses_vector;
// }
//
// std::unordered_map<std::string, TypeclassGraph::FunctionInfo> // TODO: optimize, cache
// GlobalInfo::GetAnnotatedTypeFunctionsMap(interpreter::tokens::AnnotatedType* node,
// const interpreter::tokens::BaseNode& base_node) {
//
// std::unordered_map<std::string, TypeclassGraph::FunctionInfo> functions;
//
// for (auto& typeclass : node->typeclasses) {
// utils::IdType graph_id = typeclasses_[typeclass->typeclass_id_].graph_id_;
//
// auto requirements = typeclass_graph_.GetTypeclassFunctions(graph_id);
// for (auto& requirement : requirements) {
// auto requirement_iter = functions.find(requirement.first);
// if (requirement_iter == functions.end()) {
// functions[requirement.first] = *requirement.second;
// } else {
// if (requirement_iter->second.definition.has_value()) {
// if (requirement.second->definition.has_value()) {
// error_handling::HandleTypecheckError("Function defined more then in one type requirement", base_node);
// }
// } else {
// requirement_iter->second.definition = requirement.second->definition;
// }
// }
// }
// }
// return functions;
// }
//
// std::vector<std::pair<std::string, TypeclassGraph::FunctionInfo>> // TODO: optimize, cache
// GlobalInfo::GetAnnotatedTypeFunctionsVector(interpreter::tokens::AnnotatedType* node,
// const interpreter::tokens::BaseNode& base_node) {
//
// auto functions_set = GetAnnotatedTypeFunctionsMap(node, base_node);
//
// std::vector<std::pair<std::string, TypeclassGraph::FunctionInfo>> functions_vector;
// functions_vector.reserve(functions_vector.size());
// for (auto& typeclass : functions_set) {
// functions_vector.push_back(typeclass);
// }
// return functions_vector;
// }
std::unordered_map<std::string, utils::IdType>*
GlobalInfo::ChooseNamespaces(utils::ClassInternalsModifier modifier,
@ -558,6 +558,7 @@ std::optional<utils::IdType> GlobalInfo::AddTypeclassToGraph(utils::IdType typec
definition::Namespace* parent_namespace = &GetNamespaceInfo(typeclass_info->parent_namespace);
std::string name = typeclass_info->node->definition->type->type;
interpreter::tokens::BaseNode* base_node = &typeclass_info->node->base;
std::vector<std::string> 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;
@ -566,7 +567,7 @@ std::optional<utils::IdType> GlobalInfo::AddTypeclassToGraph(utils::IdType typec
std::string dependency = dependency_node->typeclass;
if (dependency_node->parameters.size() > 0) {
error_handling::HandleInternalError("Paramtrized typeclass requirements are not implemented yet",
"TypeclassGraph.AddTypeclassByNode");
"GlobalInfo.AddTypeclassToGraph");
}
dependencies.push_back(dependency);
}
@ -595,11 +596,34 @@ std::optional<utils::IdType> GlobalInfo::AddTypeclassToGraph(utils::IdType typec
function_definitions);
}
return typeclass_graph_.AddTypeclass(name,
typeclass_info->node,
dependencies,
function_declarations,
function_definitions);
return typeclass_graph_.AddVertex(name,
dependencies,
function_declarations,
function_definitions,
base_node,
TypeclassGraph::Modifier::Typeclass);
}
std::optional<utils::IdType> GlobalInfo::AddAnnotatedTypeToGraph(interpreter::tokens::AnnotatedType* node) {
std::string name = node->type;
interpreter::tokens::BaseNode* base_node = &node->base;
std::vector<std::string> dependencies;
for (auto& dependency_node : node->typeclasses) {
std::string dependency = dependency_node->typeclass;
if (dependency_node->parameters.size() > 0) {
error_handling::HandleInternalError("Paramtrized typeclass requirements are not implemented yet",
"GlobalInfo.AddAnnotatedTypeToGraph");
}
dependencies.push_back(dependency);
}
return typeclass_graph_.AddVertex(name,
dependencies,
{},
{},
base_node,
TypeclassGraph::Modifier::Type);
}
void GlobalInfo::CollectFunctionInfo(