st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2025-12-05 22:48:42 +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

98
include/definitions.hpp Normal file
View file

@ -0,0 +1,98 @@
#pragma once
#include "interpreter_tree.hpp"
#include <string>
#include <variant>
#include <vector>
#include <optional>
#include <unordered_map>
#include <memory>
// for clangd
#include "utils.hpp"
namespace interpreter {
class Node;
} // namespace interpreter
namespace info::definition {
struct TypeUsage {
interpreter::tokens::TypeExpression* node;
};
struct Parameter {
std::string type;
std::vector<interpreter::tokens::TypeclassExpression*> typeclass_nodes;
};
struct AbstractType {
enum { Basic, Abstract } modifier;
Parameter type;
};
struct AliasType {
enum {Alias, Type, Let} modifier;
std::vector<std::string> parameters;
TypeUsage value;
interpreter::tokens::AliasDefinitionStatement* node = nullptr;
};
struct AnyType {
Parameter type;
std::vector<Parameter> parameters;
interpreter::tokens::AnyType* value;
};
struct Type {
std::variant<AbstractType, AliasType, AnyType> type;
};
struct Constructor {
std::string name;
size_t order;
utils::IdType type_id;
};
struct FunctionDeclaration {
std::vector<Parameter> parameters;
std::vector<interpreter::tokens::AnyType*> argument_types;
interpreter::tokens::FunctionDeclaration* node = nullptr;
};
struct FunctionDefinition {
std::vector<std::string> argument_names;
interpreter::tokens::FunctionDefinitionStatement* node = nullptr;
};
struct Function {
size_t argument_count = 0;
std::optional<FunctionDeclaration> declaration;
std::optional<FunctionDefinition> definition;
};
struct Typeclass {
std::vector<Parameter> parameters;
std::vector<FunctionDeclaration> requirements;
};
struct Import {
std::string module_name;
std::vector<std::string> symbols; // size = 0 => all symbols imported
};
struct Namespace {
enum Modifier { Const, Var };
std::unordered_map<std::string, utils::IdType> types;
std::unordered_map<std::string, utils::IdType> typeclasses;
std::unordered_map<std::string, utils::IdType> functions;
std::unordered_map<std::string, utils::IdType> constructors;
std::unordered_map<std::string, Namespace> namespaces;
std::unordered_map<std::string, Namespace> variable_namespaces;
std::optional<Modifier> modifier; // modifier => variable namespace
std::string type_name;
};
} // namespace info::definition

5
include/find_symbols_visitor.hpp
View file

@ -17,12 +17,13 @@ public:
private:
// Sources -----------------
void Visit(SourceFile* node) override;
void Visit(Sources* node) override;
// void Visit(SourceFile* node) override; // default
// Namespaces, partitions -----------------
// void Visit(PartitionSources* node) override; // default
void Visit(Partition* node) override;
// void Visit(NamespaceSources* node) override; // default
void Visit(Namespace* node) override;
// Definitions -----------------

67
include/global_info.hpp
View file

@ -5,7 +5,7 @@
#include <unordered_map>
// for clangd
#include "symbols_info.hpp"
#include "definitions.hpp"
#include "type_manager.hpp"
#include "utils.hpp"
@ -19,11 +19,10 @@ public:
friend GlobalInfo;
NamespaceVisitor() = delete;
public:
void AddImport(ImportInfo&& import_info, const std::optional<std::string>& name = std::nullopt);
void AddImport(definition::Import&& import_info, const std::optional<std::string>& name = std::nullopt);
void AddEnterNamespace(const std::string& name,
const std::optional<NamespaceInfo::Modifier>& modifier = std::nullopt,
const std::optional<std::string>& variable = std::nullopt);
const std::optional<definition::Namespace::Modifier>& modifier = std::nullopt);
void EnterNamespace(const std::string& name);
@ -32,29 +31,35 @@ public:
void ToGlobalNamespace();
utils::IdType AddFunctionDeclaration(const std::string& name,
FunctionDeclarationInfo&& function_declaration_info);
definition::FunctionDeclaration&& function_declaration_info);
utils::IdType AddFunctionDefinition(const std::string& name,
FunctionDefinitionInfo&& function_definition_info);
definition::FunctionDefinition&& function_definition_info);
utils::IdType AddType(const std::string& type, TypeInfo&& type_info);
utils::IdType AddType(const std::string& type, definition::Type&& type_info);
utils::IdType AddTypeclass(const std::string& typeclass, TypeclassInfo&& typeclass_info);
utils::IdType AddTypeclass(const std::string& typeclass, definition::Typeclass&& typeclass_info);
std::optional<NamespaceInfo*> FindNamespace(const std::optional<std::vector<std::string>>& path);
utils::IdType AddConstructor(const std::string& constructor,
definition::Constructor&& constructor_info);
std::optional<std::vector<utils::IdType>> FindFunction(const std::optional<std::vector<std::string>>& path,
const std::string& name);
std::optional<definition::Namespace*> FindNamespace(const std::optional<std::vector<std::string>>& path);
std::optional<std::vector<utils::IdType>> FindMethod(const std::optional<std::vector<std::string>>& path,
std::optional<utils::IdType> FindFunction(const std::optional<std::vector<std::string>>& path,
const std::string& name);
std::optional<utils::IdType> FindMethod(const std::optional<std::vector<std::string>>& path,
const std::string& type,
const std::string& name);
std::optional<std::vector<utils::IdType>> FindType(const std::optional<std::vector<std::string>>& path,
const std::string type);
std::optional<utils::IdType> FindType(const std::optional<std::vector<std::string>>& path,
const std::string& type);
std::optional<std::vector<utils::IdType>> FindTypeclass(const std::optional<std::vector<std::string>>& path,
const std::string typeclass);
std::optional<utils::IdType> FindTypeclass(const std::optional<std::vector<std::string>>& path,
const std::string& typeclass);
std::optional<utils::IdType> FindConstructor(const std::optional<std::vector<std::string>>& path,
const std::string& typeclass);
NamespaceVisitor CreateVisitor() {
return global_info_.CreateVisitor();
@ -77,12 +82,12 @@ public:
template<typename T>
std::optional<T> 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);
std::optional<NamespaceInfo*> FindNamespaceIn(NamespaceInfo* current_namespace,
std::optional<definition::Namespace*> FindNamespaceIn(definition::Namespace* current_namespace,
const std::vector<std::string>& path);
private:
std::vector<NamespaceInfo*> namespace_stack_;
std::vector<definition::Namespace*> namespace_stack_;
std::vector<std::string> current_path_;
GlobalInfo& global_info_;
@ -97,30 +102,36 @@ public:
}
// TODO: remember about vector realloc
FunctionInfo* GetFunctionInfo(utils::IdType id) {
definition::Function* GetFunctionInfo(utils::IdType id) {
return &functions_[id];
}
// TODO: remember about vector realloc
TypeInfo* GetTypeInfo(utils::IdType id) {
definition::Type* GetTypeInfo(utils::IdType id) {
return &types_[id];
}
// TODO: remember about vector realloc
TypeclassInfo* GetTypeclassInfo(utils::IdType id) {
definition::Typeclass* GetTypeclassInfo(utils::IdType id) {
return &typeclasses_[id];
}
// TODO: remember about vector realloc
definition::Constructor* GetConstructorInfo(utils::IdType id) {
return &constructors_[id];
}
private:
std::vector<FunctionInfo> functions_;
std::vector<TypeInfo> types_;
std::vector<TypeclassInfo> typeclasses_;
std::vector<definition::Function> functions_;
std::vector<definition::Type> types_;
std::vector<definition::Typeclass> typeclasses_;
std::vector<definition::Constructor> constructors_;
type::TypeManager type_manager_;
NamespaceInfo global_namespace_;
std::vector<ImportInfo> imports_;
std::unordered_map<std::string, ImportInfo> usages_;
definition::Namespace global_namespace_;
std::vector<definition::Import> imports_;
std::unordered_map<std::string, definition::Import> usages_;
};
} // namespace info

5
include/interpreter_tree.hpp
View file

@ -314,7 +314,6 @@ struct AliasDefinitionStatement {
std::vector<AbstractTypeIdentifier> parameters;
std::unique_ptr<TypeExpression> value;
std::vector<utils::IdType> parameter_graph_ids_;
utils::IdType type_id_;
};
@ -339,8 +338,6 @@ struct FunctionDefinitionStatement {
SuperExpression value;
utils::IdType function_id_;
std::vector<utils::IdType> argument_graph_ids_;
utils::IdType return_type_graph_id_;
};
struct TypeDefinitionStatement {
@ -382,8 +379,6 @@ struct TypeDefinition {
struct AnnotatedAbstractType {
AbstractTypeIdentifier type;
std::vector<std::unique_ptr<TypeclassExpression>> typeclasses;
utils::IdType type_graph_id_;
};
// ----------------- Flow control -----------------

5
include/link_symbols_visitor.hpp
View file

@ -3,7 +3,6 @@
#include <ostream>
// for clangd
#include "abstract_types_contexts.hpp"
#include "visitor.hpp"
#include "global_info.hpp"
@ -19,11 +18,12 @@ private:
// Sources -----------------
void Visit(SourceFile* node) override;
void Visit(Sources* 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 -----------------
@ -121,7 +121,6 @@ private:
private:
info::GlobalInfo::NamespaceVisitor namespace_visitor_;
info::AbstractTypesContextManager abstract_types_;
};
} // namespace interpreter

118
include/symbols_info.hpp
View file

@ -1,118 +0,0 @@
#pragma once
#include "interpreter_tree.hpp"
#include <string>
#include <variant>
#include <vector>
#include <optional>
#include <unordered_map>
#include <memory>
// for clangd
#include "utils.hpp"
namespace interpreter {
class Node;
} // namespace interpreter
namespace info {
struct VariantTypeInfo;
struct TupleTypeInfo;
struct AliasTypeInfo;
struct TypeInfo;
struct TypeclassInfo;
enum class BuiltInTypeInfo {
StringT,
IntT,
FloatT,
UnitT,
};
struct TypeUsageInfo {
interpreter::tokens::TypeExpression* node;
TypeInfo* info = nullptr;
};
struct ParameterInfo {
std::string type;
std::vector<interpreter::tokens::TypeclassExpression*> typeclass_nodes;
std::vector<TypeclassInfo*> typeclass_types;
};
struct AbstractTypeInfo {
enum { Basic, Abstract } modifier;
ParameterInfo type;
};
struct AliasTypeInfo {
enum {Alias, Type, Let} modifier;
std::vector<std::string> parameters;
TypeUsageInfo value;
};
struct AnyTypeInfo {
ParameterInfo type;
std::vector<ParameterInfo> parameters;
interpreter::tokens::AnyType* value;
};
struct TypeInfo {
std::variant<AbstractTypeInfo, AliasTypeInfo, AnyTypeInfo> type;
};
struct ConstructorInfo {
std::string name;
size_t order;
utils::IdType type_id;
};
struct FunctionDeclarationInfo {
std::vector<ParameterInfo> parameters;
std::vector<interpreter::tokens::AnyType*> argument_type_nodes;
std::vector<AnyTypeInfo*> argument_types;
interpreter::tokens::FunctionDeclaration* node = nullptr;
};
struct FunctionDefinitionInfo {
std::vector<ParameterInfo> parameters;
std::vector<std::string> argument_names;
interpreter::tokens::FunctionDefinitionStatement* node = nullptr;
};
struct FunctionInfo {
size_t argument_count = 0;
std::optional<FunctionDeclarationInfo> declaration;
std::optional<FunctionDefinitionInfo> definition;
};
struct TypeclassInfo {
std::vector<ParameterInfo> parameters;
std::vector<FunctionDeclarationInfo> requirements;
};
struct ImportInfo {
std::string module_name;
std::vector<std::string> symbols;
};
struct NamespaceInfo {
enum Modifier { Const, Var };
std::unordered_map<std::string, utils::IdType> types;
std::unordered_map<std::string, utils::IdType> typeclasses;
std::unordered_map<std::string, utils::IdType> functions;
std::unordered_map<std::string, utils::IdType> constructors;
std::unordered_map<std::string, NamespaceInfo> namespaces;
std::unordered_map<std::string, std::vector<NamespaceInfo>> variable_namespaces;
std::optional<Modifier> modifier;
std::optional<std::string> variable;
std::string type_name;
TypeInfo* type_info = nullptr;
};
} // namespace info

3
include/type_check_visitor.hpp
View file

@ -17,11 +17,12 @@ private:
// Sources -----------------
void Visit(SourceFile* node) override;
void Visit(Sources* 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 -----------------

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()) {