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

find_symbols_visitor, global_info fixed

Browse source
This commit is contained in:
ProgramSnail 2023-04-29 18:42:30 +03:00
parent 4d0b527416
commit a512a92f92
9 changed files with 289 additions and 277 deletions
Download patch file Download diff file Expand all files Collapse all files

105
src/find_symbols_visitor.cpp
View file

@ -6,51 +6,29 @@
namespace interpreter {
// Sources -----------------
void FindSymbolsVisitor::Visit(SourceFile* node) {
for (auto& statement : node->statements) {
if (std::holds_alternative<Partition>(statement)) {
Visit(&std::get<Partition>(statement));
} else if (std::holds_alternative<SourceStatement>(statement)) {
Visitor::Visit(std::get<SourceStatement>(statement));
} else {
// error
}
}
}
void FindSymbolsVisitor::Visit(Sources* node) {
for (auto& statement : node->statements) {
Visitor::Visit(statement);
}
}
// Namespaces, partitions -----------------
void FindSymbolsVisitor::Visit(Partition* node) {
// TODO
Visit(node->scope.get());
// TODO: separate partitions
Visitor::Visit(&node->scope);
}
void FindSymbolsVisitor::Visit(Namespace* node) {
std::optional<info::NamespaceInfo::Modifier> modifier;
std::optional<info::definition::Namespace::Modifier> modifier;
if (node->modifier.has_value()) {
switch (node->modifier.value()) {
case interpreter::Namespace::Var:
modifier = info::NamespaceInfo::Var;
modifier = info::definition::Namespace::Var;
break;
case interpreter::Namespace::Const:
modifier = info::NamespaceInfo::Const;
modifier = info::definition::Namespace::Const;
break;
}
}
std::optional<std::string> name;
if (node->name.has_value()) {
name = node->name.value().name;
}
namespace_visitor_.AddEnterNamespace(node->type, modifier, name);
Visit(node->scope.get());
namespace_visitor_.AddEnterNamespace(node->type, modifier);
Visitor::Visit(&node->scope);
namespace_visitor_.ExitNamespace();
}
@ -60,7 +38,7 @@ void FindSymbolsVisitor::Visit(Namespace* node) {
void FindSymbolsVisitor::Visit(ImportStatement* node) {
is_in_statement = true;
info::ImportInfo info;
info::definition::Import info;
info.module_name = node->module_name;
info.symbols = node->symbols;
namespace_visitor_.AddImport(std::move(info), node->name);
@ -71,28 +49,27 @@ void FindSymbolsVisitor::Visit(ImportStatement* node) {
void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
info::definition::Type info;
info::AliasTypeInfo alias_info;
info::definition::AliasType alias_info;
switch (node->modifier) {
case interpreter::AliasDefinitionStatement::Alias:
alias_info.modifier = info::AliasTypeInfo::Alias;
alias_info.modifier = info::definition::AliasType::Alias;
break;
case interpreter::AliasDefinitionStatement::Type:
alias_info.modifier = info::AliasTypeInfo::Type;
alias_info.modifier = info::definition::AliasType::Type;
break;
case interpreter::AliasDefinitionStatement::Let:
alias_info.modifier = info::AliasTypeInfo::Let;
alias_info.modifier = info::definition::AliasType::Let;
break;
}
alias_info.parameters = node->parameters;
node->parameter_graph_ids_.resize(node->parameters.size());
for (size_t i = 0; i < node->parameters.size(); ++i) {
node->parameter_graph_ids_[i] = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
}
// TODO: deduce parameter requirements
alias_info.parameters = node->parameters;
alias_info.value.node = node->value.get();
alias_info.node = node;
info.type = std::move(alias_info);
@ -105,18 +82,18 @@ void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
bool was_in_statement = is_in_statement;
is_in_statement = true;
info::FunctionDeclarationInfo info;
info::definition::FunctionDeclaration info;
info.parameters.resize(node->parameters.size());
for (size_t i = 0; i < node->parameters.size(); ++i) {
Visit(node->parameters[i].get());
info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
current_info_.reset();
}
info.argument_types.resize(node->type->types.size());
for (size_t i = 0; i < node->type->types.size(); ++i) {
info.argument_type_nodes[i] = &node->type->types[i];
info.argument_types[i] = &node->type->types[i];
}
info.node = node;
@ -132,26 +109,15 @@ void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
is_in_statement = true;
info::FunctionDefinitionInfo info;
info::definition::FunctionDefinition info;
auto definition = node->definition.get();
info.parameters.resize(definition->parameters.size());
for (size_t i = 0; i < definition->parameters.size(); ++i) {
Visit(definition->parameters[i].get());
info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
current_info_.reset();
}
info.argument_names.resize(definition->arguments.size());
node->argument_graph_ids_.resize(definition->arguments.size());
for (size_t i = 0; i < definition->arguments.size(); ++i) {
info.argument_names[i] = definition->arguments[i].name;
node->argument_graph_ids_[i] = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
}
node->return_type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
info.node = node;
node->function_id_ = namespace_visitor_.AddFunctionDefinition(definition->name.name, std::move(info));
@ -162,20 +128,20 @@ void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
info::definition::Type info;
auto definition = node->definition.get();
info::AnyTypeInfo any_type_info;
info::definition::AnyType any_type_info;
Visit(definition->type.get());
any_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
any_type_info.type = std::move(std::any_cast<info::definition::Parameter>(current_info_));
current_info_.reset();
any_type_info.parameters.resize(definition->parameters.size());
for (size_t i = 0; i < definition->parameters.size(); ++i) {
Visit(definition->parameters[i].get());
any_type_info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
any_type_info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
current_info_.reset();
}
@ -193,20 +159,20 @@ void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
info::definition::Type info;
info::AbstractTypeInfo abstract_type_info;
info::definition::AbstractType abstract_type_info;
Visit(node->type.get());
abstract_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
abstract_type_info.type = std::move(std::any_cast<info::definition::Parameter>(current_info_));
current_info_.reset();
switch (node->modifier) {
case interpreter::AbstractTypeDefinitionStatement::Basic:
abstract_type_info.modifier = info::AbstractTypeInfo::Basic;
abstract_type_info.modifier = info::definition::AbstractType::Basic;
break;
case interpreter::AbstractTypeDefinitionStatement::Abstract:
abstract_type_info.modifier = info::AbstractTypeInfo::Abstract;
abstract_type_info.modifier = info::definition::AbstractType::Abstract;
break;
}
@ -214,7 +180,6 @@ void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
info.type = std::move(abstract_type_info);
node->type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex(); // ??
node->type_id_ = namespace_visitor_.AddType(type, std::move(info));
is_in_statement = false;
@ -223,21 +188,21 @@ void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
is_in_statement = true;
info::TypeclassInfo info;
info::definition::Typeclass info;
auto definition = node->definition.get();
info.parameters.resize(definition->parameters.size());
for (size_t i = 0; i < definition->parameters.size(); ++i) {
Visit(definition->parameters[i].get());
info.parameters[i] = std::move(std::any_cast<info::ParameterInfo>(current_info_));
info.parameters[i] = std::move(std::any_cast<info::definition::Parameter>(current_info_));
current_info_.reset();
}
info.requirements.reserve(node->requirements.size());
for (size_t i = 0; i < node->requirements.size(); ++i) {
Visit(node->requirements[i].get());
info.requirements[i] = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
info.requirements[i] = std::move(std::any_cast<info::definition::FunctionDeclaration>(current_info_));
current_info_.reset();
}
@ -249,7 +214,7 @@ void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
// Definition parts
void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
info::ParameterInfo info;
info::definition::Parameter info;
info.type = node->type;
@ -258,8 +223,6 @@ void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
info.typeclass_nodes[i] = node->typeclasses[i].get();
}
node->type_graph_id_ = namespace_visitor_.GetAbstractTypeGraph()->AddVertex();
current_info_ = std::move(info);
}

160
src/global_info.cpp
View file

@ -1,10 +1,11 @@
// for clangd
#include "../include/global_info.hpp"
#include "../include/error_handling.hpp"
#include <variant>
namespace info {
void GlobalInfo::NamespaceVisitor::AddImport(ImportInfo&& import_info,
void GlobalInfo::NamespaceVisitor::AddImport(definition::Import&& import_info,
const std::optional<std::string>& name) {
if (name.has_value()) {
global_info_.usages_[name.value()] = std::move(import_info);
@ -14,15 +15,13 @@ void GlobalInfo::NamespaceVisitor::AddImport(ImportInfo&& import_info,
}
void GlobalInfo::NamespaceVisitor::AddEnterNamespace(const std::string& name,
const std::optional<NamespaceInfo::Modifier>& modifier,
const std::optional<std::string>& variable) {
NamespaceInfo* namespace_info = nullptr;
if (variable.has_value()) {
namespace_info = &namespace_stack_.back()->variable_namespaces[name].emplace_back();
const std::optional<definition::Namespace::Modifier>& modifier) {
definition::Namespace* namespace_info = nullptr;
if (modifier.has_value()) {
namespace_info = &namespace_stack_.back()->variable_namespaces[name];
namespace_stack_.push_back(namespace_info);
namespace_info->modifier = modifier;
namespace_info->variable = variable;
} else {
namespace_info = &namespace_stack_.back()->namespaces[name];
namespace_stack_.push_back(namespace_info);
@ -55,7 +54,7 @@ void GlobalInfo::NamespaceVisitor::ToGlobalNamespace() {
}
utils::IdType GlobalInfo::NamespaceVisitor::AddFunctionDeclaration(const std::string& name,
FunctionDeclarationInfo&& function_declaration_info) {
definition::FunctionDeclaration&& function_declaration_info) {
size_t id = 0;
auto function_id_iter = namespace_stack_.back()->functions.find(name);
@ -78,7 +77,7 @@ utils::IdType GlobalInfo::NamespaceVisitor::AddFunctionDeclaration(const std::st
}
utils::IdType GlobalInfo::NamespaceVisitor::AddFunctionDefinition(const std::string& name,
FunctionDefinitionInfo&& function_definition_info) {
definition::FunctionDefinition&& function_definition_info) {
size_t id = 0;
auto function_id_iter = namespace_stack_.back()->functions.find(name);
@ -100,53 +99,106 @@ utils::IdType GlobalInfo::NamespaceVisitor::AddFunctionDefinition(const std::str
return id;
}
// TODO - find constructors, etc.
// TODO: internal types, etc.
// TODO: extended constructor names
utils::IdType GlobalInfo::NamespaceVisitor::AddType(const std::string& type,
TypeInfo&& type_info) {
definition::Type&& type_info) {
size_t id = 0;
auto function_id_iter = namespace_stack_.back()->functions.find(type);
auto type_id_iter = namespace_stack_.back()->types.find(type);
if (function_id_iter == namespace_stack_.back()->functions.end()) {
if (type_id_iter == namespace_stack_.back()->types.end()) {
id = global_info_.types_.size();
namespace_stack_.back()->functions[type] = id;
namespace_stack_.back()->types[type] = id;
global_info_.types_.push_back(std::move(type_info));
} else {
// error
error_handling::HandleTypecheckError("More then one type with the same name in namespace");
}
definition::Type& moved_type_info = global_info_.types_.back();
if (std::holds_alternative<definition::AnyType>(moved_type_info.type)) {
definition::AnyType& any_type_info = std::get<definition::AnyType>(moved_type_info.type);
if (std::holds_alternative<std::unique_ptr<interpreter::tokens::VariantType>>(*any_type_info.value)) {
interpreter::tokens::VariantType& variant_type_info = *std::get<std::unique_ptr<interpreter::tokens::VariantType>>(*any_type_info.value);
for (size_t i = 0; i < variant_type_info.constructors.size(); ++i) {
std::string constructor_name;
definition::Constructor constructor_info;
constructor_info.type_id = id;
constructor_info.order = i;
if (std::holds_alternative<interpreter::tokens::Constructor>(variant_type_info.constructors[i])) {
constructor_name = std::get<interpreter::tokens::Constructor>(variant_type_info.constructors[i]);
} else if (std::holds_alternative<
std::unique_ptr<interpreter::tokens::TupleType>>(variant_type_info.constructors[i])) {
auto maybe_constructor_name = std::get<std::unique_ptr<interpreter::tokens::TupleType>>(variant_type_info.constructors[i])->type;
if (maybe_constructor_name.has_value()) {
constructor_name = maybe_constructor_name.value();
} else {
constructor_name = type;
}
} else {
// error
}
constructor_info.name = constructor_name;
AddConstructor(constructor_name, std::move(constructor_info));
}
}
}
return id;
}
utils::IdType GlobalInfo::NamespaceVisitor::AddTypeclass(const std::string& typeclass,
TypeclassInfo&& typeclass_info) {
definition::Typeclass&& typeclass_info) {
size_t id = 0;
auto function_id_iter = namespace_stack_.back()->functions.find(typeclass);
auto typeclass_id_iter = namespace_stack_.back()->typeclasses.find(typeclass);
if (function_id_iter == namespace_stack_.back()->functions.end()) {
if (typeclass_id_iter == namespace_stack_.back()->typeclasses.end()) {
id = global_info_.typeclasses_.size();
namespace_stack_.back()->functions[typeclass] = id;
namespace_stack_.back()->typeclasses[typeclass] = id;
global_info_.typeclasses_.push_back(std::move(typeclass_info));
} else {
// error
error_handling::HandleTypecheckError("More then one typeclass with the same name in namespace");
}
return id;
}
std::optional<NamespaceInfo*> GlobalInfo::NamespaceVisitor::FindNamespace(const std::optional<std::vector<std::string>>& path) {
return FindSomething<NamespaceInfo*>(path,
[] (NamespaceInfo* current_namespace) -> std::optional<NamespaceInfo*> {
utils::IdType GlobalInfo::NamespaceVisitor::AddConstructor(const std::string& constructor,
definition::Constructor&& constructor_info) {
size_t id = 0;
auto constructor_id_iter = namespace_stack_.back()->constructors.find(constructor);
if (constructor_id_iter == namespace_stack_.back()->constructors.end()) {
id = global_info_.constructors_.size();
namespace_stack_.back()->constructors[constructor] = id;
global_info_.constructors_.push_back(std::move(constructor_info));
} else {
error_handling::HandleTypecheckError("More then one constructor with the same name in namespace");
}
return id;
}
std::optional<definition::Namespace*> GlobalInfo::NamespaceVisitor::FindNamespace(const std::optional<std::vector<std::string>>& path) {
return FindSomething<definition::Namespace*>(path,
[] (definition::Namespace* current_namespace) -> std::optional<definition::Namespace*> {
return current_namespace;
});
}
std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindFunction(
std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindFunction(
const std::optional<std::vector<std::string>>& path,
const std::string& name) {
return FindSomething<utils::IdType>(path,
[name] (NamespaceInfo* current_namespace) -> std::optional<utils::IdType> {
[name] (definition::Namespace* current_namespace) -> std::optional<utils::IdType> {
auto function_info_iter = current_namespace->functions.find(name);
if (function_info_iter == current_namespace->functions.end()) {
@ -157,39 +209,34 @@ std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindFunc
});
}
std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindMethod(
std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindMethod(
const std::optional<std::vector<std::string>>& path,
const std::string& type,
const std::string& name) {
// TODO: remove overhead
return GlobalInfo::NamespaceVisitor::FindSomething<utils::IdType>(path,
[type, name] (NamespaceInfo* current_namespace) -> std::optional<utils::IdType> {
[type, name] (definition::Namespace* current_namespace) -> std::optional<utils::IdType> {
auto variable_namespaces_iter = current_namespace->variable_namespaces.find(type);
if (variable_namespaces_iter == current_namespace->variable_namespaces.end()) {
auto variable_namespace_iter = current_namespace->variable_namespaces.find(type);
if (variable_namespace_iter == current_namespace->variable_namespaces.end()) {
return std::nullopt;
}
for (auto& variable_namespace : variable_namespaces_iter->second) {
auto method_iter = variable_namespace.functions.find(name);
if (method_iter == variable_namespace.functions.end()) {
continue;
}
return method_iter->second;
auto method_iter = variable_namespace_iter->second.functions.find(name);
if (method_iter == variable_namespace_iter->second.functions.end()) {
return std::nullopt;
}
return std::nullopt;
return method_iter->second;
});
}
std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindType(
std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindType(
const std::optional<std::vector<std::string>>& path,
const std::string type) {
const std::string& type) {
return FindSomething<utils::IdType>(path,
[type] (NamespaceInfo* current_namespace) -> std::optional<utils::IdType> {
[type] (definition::Namespace* current_namespace) -> std::optional<utils::IdType> {
auto type_info_iter = current_namespace->types.find(type);
if (type_info_iter == current_namespace->types.end()) {
@ -200,11 +247,11 @@ std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindType
});
}
std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindTypeclass(
std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindTypeclass(
const std::optional<std::vector<std::string>>& path,
const std::string typeclass) {
const std::string& typeclass) {
return FindSomething<utils::IdType>(path,
[typeclass] (NamespaceInfo* current_namespace) -> std::optional<utils::IdType> {
[typeclass] (definition::Namespace* current_namespace) -> std::optional<utils::IdType> {
auto typeclass_info_iter = current_namespace->typeclasses.find(typeclass);
if (typeclass_info_iter == current_namespace->typeclasses.end()) {
@ -215,12 +262,27 @@ std::optional<std::vector<utils::IdType>> GlobalInfo::NamespaceVisitor::FindType
});
}
std::optional<utils::IdType> GlobalInfo::NamespaceVisitor::FindConstructor(
const std::optional<std::vector<std::string>>& path,
const std::string& constructor) {
return FindSomething<utils::IdType>(path,
[constructor] (definition::Namespace* current_namespace) -> std::optional<utils::IdType> {
auto constructor_info_iter = current_namespace->constructors.find(constructor);
if (constructor_info_iter == current_namespace->constructors.end()) {
return std::nullopt;
}
return constructor_info_iter->second;
});
}
template<typename T>
std::optional<T> GlobalInfo::NamespaceVisitor::FindSomething(
const std::optional<std::vector<std::string>>& path,
std::function<std::optional<T>(NamespaceInfo*)> search_func) {
std::function<std::optional<T>(definition::Namespace*)> search_func) {
for (ssize_t i = namespace_stack_.size() - 1; i >= 0; --i) {
NamespaceInfo* current_namespace = nullptr;
definition::Namespace* current_namespace = nullptr;
if (path.has_value()) {
auto maybe_namespace = FindNamespaceIn(namespace_stack_[i], path.value());
@ -241,10 +303,10 @@ std::optional<T> GlobalInfo::NamespaceVisitor::FindSomething(
return std::nullopt;
}
std::optional<NamespaceInfo*> GlobalInfo::NamespaceVisitor::FindNamespaceIn(
NamespaceInfo* current_namespace,
std::optional<definition::Namespace*> GlobalInfo::NamespaceVisitor::FindNamespaceIn(
definition::Namespace* current_namespace,
const std::vector<std::string>& path) {
NamespaceInfo* next_namespace = current_namespace;
definition::Namespace* next_namespace = current_namespace;
for (auto& name : path) {
auto next_namespace_iter = next_namespace->namespaces.find(name);
if (next_namespace_iter == next_namespace->namespaces.end()) {