st/lang_2023
1
0
Fork 0
mirror of https://codeberg.org/ProgramSnail/lang_2023.git synced 2026-01-25 13:07:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

part of find_symols_visitor, going to change grammar

Browse source
This commit is contained in:
ProgramSnail 2023-04-08 15:06:51 +03:00
parent 18e85f794f
commit 0d98183953
4 changed files with 158 additions and 192 deletions
Download patch file Download diff file Expand all files Collapse all files

6
include/find_symbols_visitor.hpp
View file

@ -70,8 +70,8 @@ private:
// Operators // Operators
void Visit(BinaryOperatorExpression* node) override; //// void Visit(BinaryOperatorExpression* node) override;
void Visit(UnaryOperatorExpression* node) override; //// void Visit(UnaryOperatorExpression* node) override;
// Simple Expressions // Simple Expressions
@ -94,7 +94,7 @@ private:
// Type // Type
void Visit(TypeConstructor* node) override; //// void Visit(TypeConstructor* node) override;
void Visit(TupleType* node) override; void Visit(TupleType* node) override;
void Visit(VariantType* node) override; void Visit(VariantType* node) override;
void Visit(AnnotatedType* node) override; void Visit(AnnotatedType* node) override;

2
include/interpreter_tree.hpp
View file

@ -372,7 +372,7 @@ struct DefinitionParameter : public Node {
struct DefinitionArgument : public Node { struct DefinitionArgument : public Node {
NameIdentifier name; NameIdentifier name;
std::vector<std::unique_ptr<ParametrizedType>> types; std::vector<std::unique_ptr<ParametrizedType>> types; // TODO: one type
}; };
// ----------------- Flow control ----------------- // ----------------- Flow control -----------------

41
include/symbols_info.hpp
View file

@ -50,34 +50,37 @@ enum class BuiltInTypeInfo {
FloatT, FloatT,
}; };
struct TypeUsageInfo { struct TypeUsageInfo { // TODO: typeclass_expression
std::vector<std::string> param_names; std::vector<std::string> param_names;
std::vector<TypeInfo*> param_types; std::vector<TypeInfo*> params;
std::vector<std::string> arg_names; // ??, arg expr ?? std::vector<std::string> arg_names; // ??, arg expr ??
}; };
struct ParameterInfo { struct ParameterInfo {
std::string name; std::string name;
std::vector<std::string> param_names; std::vector<std::string> param_names; // TODO: paramaters
std::vector<TypeclassInfo*> param_types; std::vector<TypeclassInfo*> param_types;
std::vector<std::string> arg_names; // ??
}; };
struct AnyTypeInfo { struct SymbolDefinitionInfo {
std::vector<ParameterInfo> params; // ?? std::string name;
std::vector<ParameterInfo> params;
std::vector<std::string> arg_names; std::vector<std::string> arg_names;
};
struct AnyTypeInfo : SymbolDefinitionInfo {
std::variant<std::unique_ptr<VariantTypeInfo>, std::variant<std::unique_ptr<VariantTypeInfo>,
std::unique_ptr<TupleTypeInfo>, std::unique_ptr<TupleTypeInfo>,
std::unique_ptr<BuiltInTypeInfo>> info; std::unique_ptr<BuiltInTypeInfo>> info;
}; };
struct VariableInfo { // struct VariableInfo {
std::string name; // std::string name;
std::optional<Value> value; // std::optional<Value> value;
TypeInfo* type = nullptr; // TypeInfo* type = nullptr;
}; // };
// TODO lambda functions as values // TODO lambda functions as value
// TODO: decide=
struct TupleTypeInfo { struct TupleTypeInfo {
std::optional<std::string> name; std::optional<std::string> name;
@ -107,22 +110,16 @@ struct FunctionDeclarationInfo {
std::vector<TypeUsageInfo> arg_types; std::vector<TypeUsageInfo> arg_types;
}; };
struct FunctionDefinitionInfo { struct FunctionDefinitionInfo : SymbolDefinitionInfo {
std::vector<ParameterInfo> params; // TODO: dublicates ??
std::vector<std::string> arg_names;
interpreter::tokens::SuperExpression* expression; interpreter::tokens::SuperExpression* expression;
}; };
struct FunctionInfo { struct FunctionInfo {
FunctionDeclarationInfo declaration; FunctionDeclarationInfo declaration;
FunctionDefinitionInfo definition; FunctionDefinitionInfo definition;
// add requirements ??
}; };
struct TypeclassInfo { struct TypeclassInfo : SymbolDefinitionInfo {
std::vector<ParameterInfo> params;
std::vector<std::string> arg_names;
std::vector<FunctionDeclarationInfo> requirements; std::vector<FunctionDeclarationInfo> requirements;
}; };
@ -142,4 +139,8 @@ struct NamespaceInfo {
TypeInfo* type_info = nullptr; TypeInfo* type_info = nullptr;
}; };
using AnyTypeVariant = std::variant<VariantTypeInfo,
TupleTypeInfo,
BuiltInTypeInfo>;
} // namespace info } // namespace info

303
src/find_symbols_visitor.cpp
View file

@ -54,7 +54,7 @@ void FindSymbolsVisitor::Visit(ImportStatement* node) {
info.module_name = node->module_name; info.module_name = node->module_name;
for (auto& symbol : node->symbols) { for (auto& symbol : node->symbols) {
Visitor::Visit(symbol); Visitor::Visit(symbol);
info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_))); info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_))); // TODO: expressions
} }
global_info_.AddImport(std::move(info)); global_info_.AddImport(std::move(info));
// TODO: what if inside usage definition, global_info_.AddImport(std::move(info)); // TODO: what if inside usage definition, global_info_.AddImport(std::move(info));
@ -71,7 +71,8 @@ void FindSymbolsVisitor::Visit(AliasDefinition* node) {
info::TypeInfo info; info::TypeInfo info;
Visit(node->type.get()); Visit(node->type.get());
auto type_info = std::move(std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_)); auto type_info = std::move(
std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
current_info_.reset(); current_info_.reset();
Visit(node->value.get()); Visit(node->value.get());
@ -117,23 +118,22 @@ void FindSymbolsVisitor::Visit(FunctionDefinition* node) {
Visit(node->name.get()); Visit(node->name.get());
auto name_info = std::move( auto name_info = std::move(
std::any_cast<std::pair<std::string, std::any_cast<info::SymbolDefinitionInfo>(current_info_));
std::pair<std::vector<info::ParameterInfo>,
std::vector<std::string>>>>(current_info_));
current_info_.reset(); current_info_.reset();
info.params = std::move(name_info.second.first); info.params = std::move(name_info.params);
info.arg_names = std::move(name_info.second.second); info.arg_names = std::move(name_info.arg_names);
info.expression = &node->value; info.expression = &node->value;
global_info_.AddFunctionDefinition(name_info.first, std::move(info)); global_info_.AddFunctionDefinition(name_info.name, std::move(info));
} }
void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition
info::TypeInfo info; info::TypeInfo info;
Visit(node->type.get()); Visit(node->type.get());
auto type_info = std::move(std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_)); auto type_info = std::move(
std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
current_info_.reset(); current_info_.reset();
Visit(node->value.get()); Visit(node->value.get());
@ -155,20 +155,16 @@ void FindSymbolsVisitor::Visit(TypeDefinition* node) {
Visit(node->type.get()); Visit(node->type.get());
auto type_info = std::move( auto type_info = std::move(
std::any_cast<std::pair<std::string, std::any_cast<info::SymbolDefinitionInfo>(current_info_));
std::pair<std::vector<info::ParameterInfo>,
std::vector<std::string>>>>(current_info_));
current_info_.reset(); current_info_.reset();
Visitor::Visit(node->value); Visitor::Visit(node->value);
auto value_info = std::move(std::any_cast<std::variant<info::VariantTypeInfo, auto value_info = std::move(std::any_cast<info::AnyTypeVariant>(current_info_));
info::TupleTypeInfo,
info::BuiltInTypeInfo>>(current_info_));
current_info_.reset(); current_info_.reset();
info::AnyTypeInfo any_type_info; info::AnyTypeInfo any_type_info;
any_type_info.params = std::move(type_info.second.first); any_type_info.params = std::move(type_info.params);
any_type_info.arg_names = std::move(type_info.second.second); any_type_info.arg_names = std::move(type_info.arg_names);
switch (value_info.index()) { switch (value_info.index()) {
case 0: case 0:
@ -193,7 +189,7 @@ void FindSymbolsVisitor::Visit(TypeDefinition* node) {
info.type = std::move(any_type_info); info.type = std::move(any_type_info);
global_info_.AddType(type_info.first, std::move(info)); global_info_.AddType(type_info.name, std::move(info));
} }
void FindSymbolsVisitor::Visit(TypeclassDefinition* node) { void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
@ -201,12 +197,10 @@ void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
Visit(node->typeclass.get()); Visit(node->typeclass.get());
auto typeclass_info = std::move( auto typeclass_info = std::move(
std::any_cast<std::pair<std::string, std::any_cast<info::SymbolDefinitionInfo>(current_info_));
std::pair<std::vector<info::ParameterInfo>,
std::vector<std::string>>>>(current_info_));
current_info_.reset(); current_info_.reset();
info.params = std::move(typeclass_info.second.first); info.params = std::move(typeclass_info.params);
info.arg_names = std::move(typeclass_info.second.second); info.arg_names = std::move(typeclass_info.arg_names);
for (auto& requirement : node->requirements) { for (auto& requirement : node->requirements) {
Visit(requirement.get()); Visit(requirement.get());
@ -215,33 +209,33 @@ void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
info.requirements.push_back(std::move(requrement_info)); info.requirements.push_back(std::move(requrement_info));
} }
global_info_.AddTypeclass(typeclass_info.first, std::move(info)); global_info_.AddTypeclass(typeclass_info.name, std::move(info));
} }
// Definition parts // Definition parts
void FindSymbolsVisitor::Visit(DefinedName* node) { void FindSymbolsVisitor::Visit(DefinedName* node) {
out_ << "(DefinedName "; info::SymbolDefinitionInfo info;
Visit(&node->name);
if (!node->parameters.empty()) { info.name = node->name;
out_ << "\n";
}
for (auto& parameter : node->parameters) { for (auto& parameter : node->parameters) {
Visit(parameter.get()); Visit(parameter.get());
} auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
if (!node->arguments.empty()) { current_info_.reset();
out_ << " : \n"; info.params.push_back(std::move(param_info));
} }
for (auto& argument : node->arguments) { for (auto& argument : node->arguments) {
Visit(argument.get()); Visit(argument.get());
} auto argument_info = std::move(std::any_cast<std::string>(current_info_));
out_ << ")"; current_info_.reset();
info.arg_names.push_back(std::move(argument_info));
} }
void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) { current_info_ = std::move(info);
out_ << "(DefinedAnnotatedName "; }
Visit(&node->name);
out_ << " : "; void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) { // TODO: remove
// Visit(&node->name);
if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) { if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get()); Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
} else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) { } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
@ -249,244 +243,215 @@ void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) {
} else { } else {
// no annotation // no annotation
} }
out_ << " )";
} }
void FindSymbolsVisitor::Visit(DefinedType* node) { void FindSymbolsVisitor::Visit(DefinedType* node) {
out_ << "(DefinedType "; info::SymbolDefinitionInfo info;
Visit(node->type.get()); Visit(node->type.get());
if (!node->parameters.empty()) { info.name = /*...*/; // TODO
out_ << "\n";
}
for (auto& parameter : node->parameters) { for (auto& parameter : node->parameters) {
Visit(parameter.get()); Visit(parameter.get());
} auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
if (!node->arguments.empty()) { current_info_.reset();
out_ << " : \n"; info.params.push_back(std::move(param_info));
} }
for (auto& argument : node->arguments) { for (auto& argument : node->arguments) {
Visit(argument.get()); Visit(argument.get());
auto argument_info = std::move(std::any_cast<std::string>(current_info_));
current_info_.reset();
info.arg_names.push_back(std::move(argument_info));
} }
out_ << ")";
current_info_ = std::move(info);
} }
void FindSymbolsVisitor::Visit(DefinedTypeclass* node) { void FindSymbolsVisitor::Visit(DefinedTypeclass* node) {
out_ << "(DefinedTypeclass "; info::SymbolDefinitionInfo info;
Visit(node->typeclass.get()); Visit(node->typeclass.get());
if (!node->parameters.empty()) { info.name = /*...*/; // TODO
out_ << "\n";
}
for (auto& parameter : node->parameters) { for (auto& parameter : node->parameters) {
Visit(parameter.get()); Visit(parameter.get());
} auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
if (!node->arguments.empty()) { current_info_.reset();
out_ << " : \n"; info.params.push_back(std::move(param_info));
} }
for (auto& argument : node->arguments) { for (auto& argument : node->arguments) {
Visit(argument.get()); Visit(argument.get());
auto argument_info = std::move(std::any_cast<std::string>(current_info_));
current_info_.reset();
info.arg_names.push_back(std::move(argument_info));
} }
out_ << ")";
current_info_ = std::move(info);
} }
void FindSymbolsVisitor::Visit(DefinitionParameter* node) { void FindSymbolsVisitor::Visit(DefinitionParameter* node) {
out_ << "(DefinitionParameter " << (!node->typeclasses.empty() > 0 ? "(" : ""); info::ParameterInfo info;
Visit(&node->type);
out_ << ' '; info.name = node->type;
for (auto& typeclass : node->typeclasses) { for (auto& typeclass : node->typeclasses) {
Visit(typeclass.get()); Visit(typeclass.get());
auto typeclass_info = std::move(std::any_cast</*...*/>(current_info_));
current_info_.reset();
info.param_names.push_back(std::move(typeclass_info));
} }
out_ << ")";
current_info_ = std::move(info);
} }
void FindSymbolsVisitor::Visit(DefinitionArgument* node) { void FindSymbolsVisitor::Visit(DefinitionArgument* node) {
out_ << "(DefinitionArgument " << (!node->types.empty() ? "(" : ""); std::string info; // TODO: add type
Visit(&node->name);
out_ << ' '; info = node->name;
for (auto& type : node->types) {
Visit(type.get()); // for (auto& type : node->types) {
} // Visit(type.get());
out_ << ")"; // auto argument_info = std::move(std::any_cast<std::string>(current_info_));
// current_info_.reset();
// info.types.push_back(std::move(argument_info));
// }
current_info_ = std::move(info);
} }
// Statements, expressions, blocks, etc. ----------------- // Statements, expressions, blocks, etc. -----------------
// Name // Name
void FindSymbolsVisitor::Visit(NameSuperExpression* node) { // void FindSymbolsVisitor::Visit(NameSuperExpression* node) {
out_ << "(NameSuperExpression "; // for (auto& variable_namespace : node->namespaces) {
for (auto& variable_namespace : node->namespaces) { // Visitor::Visit(variable_namespace);
Visitor::Visit(variable_namespace); // }
out_ << '.'; // for (size_t i = 0; i < node->expressions.size(); ++i) {
} // Visitor::Visit(node->expressions[i]);
for (size_t i = 0; i < node->expressions.size(); ++i) { // if (i + 1 < node->expressions.size()) {
Visitor::Visit(node->expressions[i]); // }
if (i + 1 < node->expressions.size()) { // }
out_ << '.'; // }
} //
} // void FindSymbolsVisitor::Visit(NameExpression* node) {
out_ << ")"; // for (auto& variable_namespace : node->namespaces) {
} // Visitor::Visit(variable_namespace);
// }
void FindSymbolsVisitor::Visit(NameExpression* node) { // for (size_t i = 0; i < node->names.size(); ++i) {
out_ << "(NameExpression "; // Visit(&node->names[i]);
for (auto& variable_namespace : node->namespaces) { // if (i + 1 < node->names.size()) {
Visitor::Visit(variable_namespace); // }
out_ << '.'; // }
} // }
for (size_t i = 0; i < node->names.size(); ++i) { //
Visit(&node->names[i]); // void FindSymbolsVisitor::Visit(TupleName* node) {
if (i + 1 < node->names.size()) { // for (auto& name : node->names) {
out_ << '.'; // Visit(name.get());
} // }
} // }
out_ << ")"; //
} // void FindSymbolsVisitor::Visit(VariantName* node) {
// for (auto& name : node->names) {
void FindSymbolsVisitor::Visit(TupleName* node) { // Visit(name.get());
out_ << "(TupleName "; // }
for (auto& name : node->names) { // }
out_ << '&'; //
Visit(name.get()); // void FindSymbolsVisitor::Visit(AnnotatedName* node) {
} // Visit(&node->name);
out_ << ")"; // if (node->type.has_value()) {
} // Visit(node->type.value().get());
// }
void FindSymbolsVisitor::Visit(VariantName* node) { // }
out_ << "(VariantName ";
for (auto& name : node->names) {
out_ << '|';
Visit(name.get());
}
out_ << ")";
}
void FindSymbolsVisitor::Visit(AnnotatedName* node) {
out_ << "(AnnotatedName ";
Visit(&node->name);
if (node->type.has_value()) {
out_ << " : ";
Visit(node->type.value().get());
}
out_ << " )";
}
// Type // Type
void FindSymbolsVisitor::Visit(TypeConstructor* node) {
out_ << "(TypeConstructor ";
Visit(node->type.get());
out_ << '\n';
for (auto& parameter : node->parameters) {
Visit(&parameter.first);
out_ << " = ";
Visitor::Visit(parameter.second);
out_ << '\n';
}
out_ << ")";
}
void FindSymbolsVisitor::Visit(TupleType* node) { void FindSymbolsVisitor::Visit(TupleType* node) {
out_ << "(TupleType "; info::TupleTypeInfo info;
if (node->type.has_value()) { if (node->type.has_value()) {
Visit(&node->type.value()); info.name = node->type.value();
} }
out_ << ' ';
for (auto& entity : node->entities) { for (auto& entity : node->entities) {
out_ << "& "; info.fields.emplace_back();
if (entity.first.has_value()) { if (entity.first.has_value()) {
Visit(&entity.first.value()); info.fields.back().first = entity.first.value();
out_ << " : ";
} }
Visitor::Visit(entity.second); Visitor::Visit(entity.second);
auto entity_type_info = std::move(std::any_cast<info::AnyTypeInfo>(current_info_));
current_info_.reset();
info.fields.back().second = std::move(entity_type_info);
} }
out_ << ")";
current_info_ = info::AnyTypeVariant(std::move(info));
} }
void FindSymbolsVisitor::Visit(VariantType* node) { void FindSymbolsVisitor::Visit(VariantType* node) {
out_ << "(VariantType "; info::VariantTypeInfo info;
if (node->type.has_value()) { if (node->type.has_value()) {
Visit(&node->type.value()); info.name = node->type.value();ParametrizedType
} }
out_ << ' ';
for (auto& constructor : node->constructors) { for (auto& constructor : node->constructors) {
out_ << "| ";
if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) { if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
Visit(&std::get<TypeIdentifierDefinition>(constructor)); info.constructors.push_back(std::get<TypeIdentifierDefinition>(constructor));
} else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) { } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
Visit(std::get<std::unique_ptr<TupleType>>(constructor).get()); Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
auto constructor_tuple_info = std::move(std::any_cast<info::TupleTypeInfo>(current_info_));
current_info_.reset();
info.constructors.push_back(std::move(constructor_tuple_info));
} else { } else {
// error // error
} }
} }
out_ << ")";
current_info_ = info::AnyTypeVariant(std::move(info));
} }
void FindSymbolsVisitor::Visit(AnnotatedType* node) { void FindSymbolsVisitor::Visit(AnnotatedType* node) {
out_ << "(AnnotatedType ";
Visit(node->type_expression.get()); Visit(node->type_expression.get());
if (!node->annotations.empty()) { if (!node->annotations.empty()) {
out_ << " :";
} }
for (auto& annotation : node->annotations) { for (auto& annotation : node->annotations) {
out_ << " ";
Visit(annotation.get()); Visit(annotation.get());
} }
out_ << ")";
} }
void FindSymbolsVisitor::Visit(ParametrizedType* node) { void FindSymbolsVisitor::Visit(ParametrizedType* node) {
out_ << "(ParametrizedType ";
Visit(node->type_expression.get()); Visit(node->type_expression.get());
for (auto& parameter : node->parameters) { for (auto& parameter : node->parameters) {
out_ << ' ';
Visitor::Visit(parameter); Visitor::Visit(parameter);
} }
out_ << " )";
} }
void FindSymbolsVisitor::Visit(TypeExpression* node) { void FindSymbolsVisitor::Visit(TypeExpression* node) {
out_ << "(TypeExpression ";
for (auto& type_namespace : node->namespaces) { for (auto& type_namespace : node->namespaces) {
Visitor::Visit(type_namespace); Visitor::Visit(type_namespace);
out_ << '.';
} }
Visit(&node->type); Visit(&node->type);
out_ << " )";
} }
// Typeclass // Typeclass
void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) { void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) {
out_ << "(AnnotatedTypeclass ";
Visit(node->typeclass_expression.get()); Visit(node->typeclass_expression.get());
if (!node->annotations.empty()) { if (!node->annotations.empty()) {
out_ << " :";
} }
for (auto& annotation : node->annotations) { for (auto& annotation : node->annotations) {
out_ << " ";
Visit(annotation.get()); Visit(annotation.get());
} }
out_ << ")";
} }
void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) { void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
out_ << "(ParametrizedTypeclass ";
Visit(node->typeclass_expression.get()); Visit(node->typeclass_expression.get());
for (auto& paramater : node->parameters) { for (auto& paramater : node->parameters) {
out_ << ' ';
Visitor::Visit(paramater); Visitor::Visit(paramater);
} }
out_ << " )";
} }
void FindSymbolsVisitor::Visit(TypeclassExpression* node) { void FindSymbolsVisitor::Visit(TypeclassExpression* node) {
out_ << "(TypeclassExpression ";
for (auto& typeclass_namespace : node->namespaces) { for (auto& typeclass_namespace : node->namespaces) {
Visitor::Visit(typeclass_namespace); Visitor::Visit(typeclass_namespace);
out_ << '.';
} }
Visit(&node->typeclass); Visit(&node->typeclass);
out_ << " )";
} }
} // namespace interpreter } // namespace interpreter