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

first iteration of find_symbols_visitor

Browse source
This commit is contained in:
ProgramSnail 2023-04-12 13:31:39 +03:00
parent 87bd815bbb
commit 399631b9ca
13 changed files with 92065 additions and 92399 deletions
Download patch file Download diff file Expand all files Collapse all files

1
CMakeLists.txt
View file

@ -20,6 +20,7 @@ add_executable(lang_interpreter src/main.cpp
src/visitor.cpp
src/build_visitor.cpp
src/print_visitor.cpp
src/find_symbols_visitor.cpp
src/parser.c
include/parser.h
tree-sitter/lib/src/lib.c)

3
include/build_visitor.hpp
View file

@ -43,7 +43,7 @@ private:
void Visit(FunctionDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(DefinitionParameter* node) override;
void Visit(AnyAnnotatedType* node) override;
// Flow control -----------------
@ -108,7 +108,6 @@ private:
void Visit(FunctionType* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(AnnotatedType* node) override;
void Visit(ParametrizedType* node) override;
void Visit(TypeExpression* node) override;

73
include/find_symbols_visitor.hpp
View file

@ -18,8 +18,6 @@ public:
explicit FindSymbolsVisitor(info::GlobalInfo& global_info) : global_info_(global_info) {}
private:
//// void Visit(Node* node) override;
// Sources -----------------
void Visit(SourceFile* node) override;
@ -33,23 +31,19 @@ private:
// Definitions -----------------
void Visit(ImportStatement* node) override;
void Visit(UsageDefinition* node) override;
void Visit(AliasDefinition* node) override;
//// void Visit(VariableDefinition* node) override; // TODO: decide
void Visit(AliasDefinitionStatement* node) override;
// // void Visit(VariableDefinitionStatement* node) override;
void Visit(FunctionDeclaration* node) override;
void Visit(FunctionDefinition* node) override;
void Visit(AliasTypeDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(TypeclassDefinition* node) override;
void Visit(FunctionDefinitionStatement* node) override;
void Visit(TypeDefinitionStatement* node) override;
void Visit(AbstractTypeDefinitionStatement* node) override;
void Visit(TypeclassDefinitionStatement* node) override;
// Definition parts
void Visit(DefinedName* node) override;
void Visit(DefinedAnnotatedName* node) override;
void Visit(DefinedType* node) override;
void Visit(DefinedTypeclass* node) override;
void Visit(DefinitionParameter* node) override;
void Visit(DefinitionArgument* node) override;
// // void Visit(FunctionDefinition* node) override;
// // void Visit(TypeDefinition* node) override;
void Visit(AnyAnnotatedType* node) override;
// Flow control -----------------
@ -64,59 +58,66 @@ private:
// Statements, expressions, blocks, etc. -----------------
// // void Visit(Block* node) override;
// //
// // void Visit(ScopedStatement* node) override;
//// void Visit(LoopControlExpression& node) override; // enum
// Operators
// // void Visit(BinaryOperatorExpression* node) override;
// // void Visit(UnaryOperatorExpression* node) override;
// // void Visit(ReferenceExpression* node) override;
// Simple Expressions
// // void Visit(FunctionCallExpression* node) override;
// //
// // void Visit(TupleExpression* node) override;
// // void Visit(VariantExpression* node) override;
// // void Visit(ReturnExpression* node) override;
// Lambda
// // void Visit(TypeConstructor* node) override;
// // void Visit(LambdaFunction* node) override;
// // void Visit(ArrayExpression* node) override;
// //
// // void Visit(LoopControlExpression& node) override; // enum
// Name
void Visit(NameSuperExpression* node) override;
void Visit(NameExpression* node) override;
void Visit(TupleName* node) override;
void Visit(VariantName* node) override;
void Visit(AnnotatedName* node) override;
// // void Visit(NameExpression* node) override;
// // void Visit(TupleName* node) override;
// // void Visit(VariantName* node) override;
// // void Visit(AnnotatedName* node) override;
// Type, typeclass, etc. -----------------
// Type
//// void Visit(TypeConstructor* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(AnnotatedType* node) override;
void Visit(ParametrizedType* node) override;
void Visit(TypeExpression* node) override;
// // void Visit(FunctionType* node) override;
// // void Visit(TupleType* node) override;
// // void Visit(VariantType* node) override;
// // void Visit(ParametrizedType* node) override;
// // void Visit(TypeExpression* node) override;
// //
// // void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
void Visit(AnnotatedTypeclass* node) override;
void Visit(ParametrizedTypeclass* node) override;
void Visit(TypeclassExpression* node) override;
// // void Visit(ParametrizedTypeclass* node) override;
// // void Visit(TypeclassExpression* node) override;
// Identifiers, constants, etc. -----------------
//// void Visit(AnyIdentifier* node) override; // std::string
// // void Visit(ExtendedName* node) override;
// //
// // void Visit(std::string* node) override; // std::string
// //
// // void Visit(FloatNumberLiteral* node) override;
// // void Visit(NumberLiteral* node) override;
// // void Visit(StringLiteral* node) override;
// // void Visit(CharLiteral* node) override;
private:
info::GlobalInfo& global_info_;
bool is_in_statement = false;
std::any current_info_;
};

48
include/global_info.hpp
View file

@ -15,29 +15,22 @@ public:
namespace_stack.push_back(&global_namespace_);
}
template<typename T>
void AddImport(T&& import_info) {
if (waiting_usage.has_value()) {
usages_[waiting_usage.value()] = std::forward(import_info);
waiting_usage = std::nullopt;
void AddImport(ImportInfo&& import_info, const std::optional<std::string>& name = std::nullopt) {
if (name.has_value()) {
usages_[name.value()] = std::move(import_info);
} else {
imports_.push_back(std::forward(import_info));
imports_.push_back(std::move(import_info));
}
}
void AddUsageForNextImport(const std::string& name) {
if (waiting_usage.has_value()) {
// error
}
waiting_usage = name;
}
void AddEnterNamespace(const std::optional<std::string>& var,
const std::string& type) {
void AddEnterNamespace(const std::string& type,
const std::optional<NamespaceInfo::Modifier>& modifier = std::nullopt,
const std::optional<std::string>& variable = std::nullopt) {
NamespaceInfo* namespace_info = &namespace_stack.back()->namespaces[type].emplace_back();
namespace_stack.push_back(namespace_info);
namespace_info->var = var;
namespace_info->modifier = modifier;
namespace_info->variable = variable;
namespace_info->type_name = type;
}
@ -55,36 +48,30 @@ public:
namespace_stack.push_back(&global_namespace_);
}
template<typename T>
void AddFunctionDeclaration(const std::string& name,
T&& function_declaration_info) {
FunctionDeclarationInfo&& function_declaration_info) {
FunctionInfo* function_info = &namespace_stack.back()->functions[name];
function_info->declaration = std::forward(function_declaration_info);
function_info->declaration = std::move(function_declaration_info);
}
template<typename T>
void AddFunctionDefinition(const std::string& name,
T&& function_definition_info) {
FunctionDefinitionInfo&& function_definition_info) {
FunctionInfo* function_info = &namespace_stack.back()->functions[name];
function_info->definition = std::forward(function_definition_info);
function_info->definition = std::move(function_definition_info);
}
template<typename T>
void AddType(const std::string& type,
T&& type_info) {
&namespace_stack.back()->types[type] = std::forward(type_info);
TypeInfo&& type_info) {
namespace_stack.back()->types[type] = std::move(type_info);
}
template<typename T>
void AddTypeclass(const std::string& typeclass,
T&& typeclass_info) {
namespace_stack.back()->typeclasses[typeclass] = std::forward(typeclass_info);
TypeclassInfo&& typeclass_info) {
namespace_stack.back()->typeclasses[typeclass] = std::move(typeclass_info);
}
// AddVar ?? // TODO: decide
// FindFunction
// FindType
@ -92,7 +79,6 @@ public:
private:
std::vector<NamespaceInfo*> namespace_stack;
std::optional<std::string> waiting_usage;
NamespaceInfo global_namespace_;
std::vector<ImportInfo> imports_;

24
include/interpreter_tree.hpp
View file

@ -56,7 +56,12 @@ using ImportSymbol = AnyIdentifier;
struct FunctionDefinition;
struct TypeDefinition;
struct DefinitionParameter;
struct AnnotatedAbstractType;
// TypeIdentifier <-> AbstractTypeIdentifier <-> std::string
using AnnotatedType = AnnotatedAbstractType;
using AnyAnnotatedType = AnnotatedType;
// Flow control -----------------
@ -168,8 +173,6 @@ using ScopedAnyName = AnyName;
struct FunctionType;
struct TupleType;
struct VariantType;
struct AnnotatedType;
struct ParametrizedType;
struct TypeExpression;
@ -301,7 +304,7 @@ struct VariableDefinitionStatement {
struct FunctionDeclaration {
NameOrOperatorIdentifier name;
std::vector<std::unique_ptr<DefinitionParameter>> parameters;
std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
std::unique_ptr<FunctionType> type;
};
@ -332,16 +335,16 @@ struct TypeclassDefinitionStatement {
struct FunctionDefinition {
enum { Operator, Function } modifier;
NameOrOperatorIdentifier name;
std::vector<std::unique_ptr<DefinitionParameter>> parameters;
std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
std::vector<ExtendedName> arguments;
};
struct TypeDefinition {
std::unique_ptr<AnnotatedType> type;
std::vector<std::unique_ptr<DefinitionParameter>> parameters;
std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
};
struct DefinitionParameter {
struct AnnotatedAbstractType {
AbstractTypeIdentifier type;
std::vector<TypeclassUsage> typeclasses;
};
@ -444,7 +447,7 @@ struct TypeConstructor {
};
struct LambdaFunction {
std::vector<std::unique_ptr<DefinitionParameter>> parameters;
std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
std::vector<ExtendedName> arguments;
Expression expression;
};
@ -491,11 +494,6 @@ struct VariantType {
std::vector<std::variant<Constructor, std::unique_ptr<TupleType>>> constructors;
};
struct AnnotatedType {
std::unique_ptr<TypeExpression> type_expression;
std::vector<TypeclassUsage> annotations;
};
struct ParametrizedType {
std::unique_ptr<TypeExpression> type_expression;
std::vector<TypeParameter> parameters;

4
include/parse_token_types.hpp
View file

@ -32,7 +32,8 @@ const std::string TypeclassDefinitionStatement = "typeclass_definition_statement
const std::string ImportSymbol = "import_symbol";
const std::string FunctionDefinition = "function_definition";
const std::string TypeDefinition = "type_definition";
const std::string DefinitionParameter = "definition_parameter";
const std::string AnnotatedAbstractType = "annotated_abstract_type";
const std::string AnnotatedType = "annotated_type";
// Flow control -----------------
@ -91,7 +92,6 @@ const std::string ScopedAnyName = "scoped_any_name";
const std::string FunctionType = "function_type";
const std::string TupleType = "tuple_type";
const std::string VariantType = "variant_type";
const std::string AnnotatedType = "annotated_type";
const std::string ParametrizedType = "parametrized_type";
const std::string TypeExpression = "type_expression";
const std::string Constructor = "constructor";

3
include/print_visitor.hpp
View file

@ -37,7 +37,7 @@ private:
void Visit(FunctionDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(DefinitionParameter* node) override;
void Visit(AnyAnnotatedType* node) override;
// Flow control -----------------
@ -88,7 +88,6 @@ private:
void Visit(FunctionType* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(AnnotatedType* node) override;
void Visit(ParametrizedType* node) override;
void Visit(TypeExpression* node) override;

90
include/symbols_info.hpp
View file

@ -50,68 +50,46 @@ enum class BuiltInTypeInfo {
FloatT,
};
struct TypeUsageInfo { // TODO: typeclass_expression
std::vector<std::string> param_names;
std::vector<TypeInfo*> params;
std::vector<std::string> arg_names; // ??, arg expr ??
struct TypeUsageInfo {
interpreter::tokens::ParametrizedType* node;
TypeInfo* info = nullptr;
};
struct ParameterInfo {
std::string name;
std::vector<std::string> param_names; // TODO: paramaters
std::vector<TypeclassInfo*> param_types;
std::string type;
std::vector<interpreter::tokens::TypeclassUsage*> typeclass_nodes;
std::vector<TypeclassInfo*> typeclass_types;
};
struct SymbolDefinitionInfo {
std::string name;
std::vector<ParameterInfo> params;
std::vector<std::string> arg_names;
};
struct AnyTypeInfo : SymbolDefinitionInfo {
std::variant<std::unique_ptr<VariantTypeInfo>,
std::unique_ptr<TupleTypeInfo>,
std::unique_ptr<BuiltInTypeInfo>> info;
};
// struct VariableInfo {
// std::string name;
// std::optional<Value> value;
// TypeInfo* type = nullptr;
// };
// TODO lambda functions as value
// TODO: decide=
struct TupleTypeInfo {
std::optional<std::string> name;
std::vector<std::pair<std::optional<std::string>, AnyTypeInfo>> fields;
};
struct VariantTypeInfo {
std::optional<std::string> name;
std::vector<std::variant<std::string, TupleTypeInfo>> constructors;
// ?? any type instead of tuple type ??
struct AbstractTypeInfo {
enum { Basic, Abstract } modifier;
ParameterInfo type;
};
struct AliasTypeInfo {
std::vector<std::string> params;
bool isAnotherType;
enum {Alias, Type, Let} modifier;
std::vector<std::string> parameters;
TypeUsageInfo value;
};
struct TypeInfo { std::variant<AliasTypeInfo, AnyTypeInfo> type; };
// struct PointerInfo { // ??
// VariableInfo* variable;
// };
struct FunctionDeclarationInfo {
std::vector<ParameterInfo> params;
std::vector<TypeUsageInfo> arg_types;
struct AnyTypeInfo {
ParameterInfo type;
std::vector<ParameterInfo> parameters;
interpreter::tokens::AnyType* value;
};
struct FunctionDefinitionInfo : SymbolDefinitionInfo {
interpreter::tokens::SuperExpression* expression;
struct TypeInfo { std::variant<AbstractTypeInfo, AliasTypeInfo, AnyTypeInfo> type; };
struct FunctionDeclarationInfo {
std::vector<ParameterInfo> parameters;
std::vector<interpreter::tokens::AnyType*> argument_type_nodes;
std::vector<AnyTypeInfo*> argument_types;
};
struct FunctionDefinitionInfo {
std::vector<ParameterInfo> parameters;
std::vector<std::string> argument_names;
interpreter::tokens::SuperExpression* expression = nullptr;
};
struct FunctionInfo {
@ -119,7 +97,8 @@ struct FunctionInfo {
FunctionDefinitionInfo definition;
};
struct TypeclassInfo : SymbolDefinitionInfo {
struct TypeclassInfo {
std::vector<ParameterInfo> parameters;
std::vector<FunctionDeclarationInfo> requirements;
};
@ -129,18 +108,17 @@ struct ImportInfo {
};
struct NamespaceInfo {
enum Modifier { Const, Var };
std::unordered_map<std::string, TypeInfo> types;
std::unordered_map<std::string, TypeclassInfo> typeclasses;
// std::unordered_map<std::string, VariableInfo> variables; // TODO
std::unordered_map<std::string, FunctionInfo> functions;
std::unordered_map<std::string, std::vector<NamespaceInfo>> namespaces;
std::optional<std::string> var;
std::optional<Modifier> modifier;
std::optional<std::string> variable;
std::string type_name;
TypeInfo* type_info = nullptr;
};
using AnyTypeVariant = std::variant<VariantTypeInfo,
TupleTypeInfo,
BuiltInTypeInfo>;
} // namespace info

3
include/visitor.hpp
View file

@ -41,7 +41,7 @@ protected:
virtual void Visit(FunctionDefinition* node) {}
virtual void Visit(TypeDefinition* node) {}
virtual void Visit(DefinitionParameter* node) {}
virtual void Visit(AnyAnnotatedType* node) {}
// Flow control -----------------
@ -106,7 +106,6 @@ protected:
virtual void Visit(FunctionType* node) {}
virtual void Visit(TupleType* node) {}
virtual void Visit(VariantType* node) {}
virtual void Visit(AnnotatedType* node) {}
virtual void Visit(ParametrizedType* node) {}
virtual void Visit(TypeExpression* node) {}

35
src/build_visitor.cpp
View file

@ -200,7 +200,7 @@ void BuildVisitor::Visit(FunctionDeclaration* node) {
for (size_t i = 0; i + 2 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->parameters.push_back(std::make_unique<DefinitionParameter>());
node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
Visit(node->parameters.back().get());
}
@ -346,12 +346,12 @@ void BuildVisitor::Visit(FunctionDefinition* node) {
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
if (current_node_.GetType() != parser::tokens::AnnotatedAbstractType) {
parameters_ended = true;
}
if (!parameters_ended) {
node->parameters.push_back(std::make_unique<DefinitionParameter>());
node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
Visit(node->parameters.back().get());
} else {
node->arguments.emplace_back();
@ -375,7 +375,7 @@ void BuildVisitor::Visit(TypeDefinition* node) {
if (child_count > 1) {
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
node->parameters.push_back(std::make_unique<DefinitionParameter>());
node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
Visit(node->parameters.back().get());
}
}
@ -383,7 +383,7 @@ void BuildVisitor::Visit(TypeDefinition* node) {
current_node_ = parse_node;
}
void BuildVisitor::Visit(DefinitionParameter* node) {
void BuildVisitor::Visit(AnyAnnotatedType* node) {
auto parse_node = current_node_;
node->type = parse_node.ChildByFieldName("type").GetValue();
@ -904,12 +904,12 @@ void BuildVisitor::Visit(LambdaFunction* node) {
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i);
if (current_node_.GetType() != parser::tokens::DefinitionParameter) {
if (current_node_.GetType() != parser::tokens::AnnotatedAbstractType) {
parameters_ended = true;
}
if (!parameters_ended) {
node->parameters.push_back(std::make_unique<DefinitionParameter>());
node->parameters.push_back(std::make_unique<AnnotatedAbstractType>());
Visit(node->parameters.back().get());
} else {
node->arguments.emplace_back();
@ -1155,27 +1155,6 @@ void BuildVisitor::Visit(VariantType* node) {
current_node_ = parse_node;
}
void BuildVisitor::Visit(AnnotatedType* node) {
auto parse_node = current_node_;
current_node_ = parse_node.ChildByFieldName("type_expression");
node->type_expression = std::make_unique<TypeExpression>();
Visit(node->type_expression.get());
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->annotations.resize(child_count - 1);
for (size_t i = 0; i + 1 < child_count; ++i) {
current_node_ = parse_node.NthNamedChild(i + 1);
Visit(node->annotations[i]);
}
}
current_node_ = parse_node;
}
void BuildVisitor::Visit(ParametrizedType* node) {
auto parse_node = current_node_;

518
src/find_symbols_visitor.cpp
View file

@ -30,19 +30,24 @@ void FindSymbolsVisitor::Visit(Partition* node) {
}
void FindSymbolsVisitor::Visit(Namespace* node) {
if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
auto info = std::move(std::any_cast<std::pair<std::string, std::string>>(current_info_));
global_info_.AddEnterNamespace(info.first, info.second);
current_info_.reset();
} else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
auto info = std::move(std::any_cast<std::string>(current_info_));
global_info_.AddEnterNamespace(std::nullopt, info);
current_info_.reset();
} else {
// error
std::optional<info::NamespaceInfo::Modifier> modifier;
if (node->modifier.has_value()) {
switch (node->modifier.value()) {
case interpreter::Namespace::Var:
modifier = info::NamespaceInfo::Var;
break;
case interpreter::Namespace::Const:
modifier = info::NamespaceInfo::Const;
break;
}
}
std::optional<std::string> name;
if (node->name.has_value()) {
name = node->name.value().name;
}
global_info_.AddEnterNamespace(node->type, modifier, name);
Visit(node->scope.get());
global_info_.ExitNamespace();
}
@ -50,408 +55,197 @@ void FindSymbolsVisitor::Visit(Namespace* node) {
// Definitions -----------------
void FindSymbolsVisitor::Visit(ImportStatement* node) {
is_in_statement = true;
info::ImportInfo info;
info.module_name = node->module_name;
for (auto& symbol : node->symbols) {
Visitor::Visit(symbol);
info.symbols.push_back(std::move(std::any_cast<std::string>(current_info_))); // TODO: expressions
}
global_info_.AddImport(std::move(info));
// TODO: what if inside usage definition, global_info_.AddImport(std::move(info));
}
info.symbols = node->symbols;
global_info_.AddImport(std::move(info), node->name);
void FindSymbolsVisitor::Visit(UsageDefinition* node) {
global_info_.AddUsageForNextImport(node->name);
Visit(node->import_statement.get());
is_in_statement = false;
}
// <-- current position
void FindSymbolsVisitor::Visit(AliasDefinition* node) {
void FindSymbolsVisitor::Visit(AliasDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
Visit(node->type.get());
auto type_info = std::move(
std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
current_info_.reset();
Visit(node->value.get());
auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
current_info_.reset();
info::AliasTypeInfo alias_info;
alias_info.isAnotherType = false;
alias_info.params = std::move(type_info.second);
alias_info.value = std::move(value_info);
switch (node->modifier) {
case interpreter::AliasDefinitionStatement::Alias:
alias_info.modifier = info::AliasTypeInfo::Alias;
break;
case interpreter::AliasDefinitionStatement::Type:
alias_info.modifier = info::AliasTypeInfo::Type;
break;
case interpreter::AliasDefinitionStatement::Let:
alias_info.modifier = info::AliasTypeInfo::Let;
break;
}
alias_info.parameters = node->parameters;
alias_info.value.node = node->value.get();
info.type = std::move(alias_info);
global_info_.AddType(type_info.first, info);
}
global_info_.AddType(node->type, std::move(info));
// void FindSymbolsVisitor::Visit(VariableDefinition* node) { // TODO: decide
// out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
// Visit(&node->name);
// out_ << " = ";
// Visitor::Visit(node->value);
// out_ << ")\n";
// }
is_in_statement = false;
}
void FindSymbolsVisitor::Visit(FunctionDeclaration* node) {
bool was_in_statement = is_in_statement;
is_in_statement = true;
info::FunctionDeclarationInfo info;
for (auto& parameter : node->parameters) {
Visit(parameter.get());
auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_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_));
current_info_.reset();
info.params.push_back(std::move(param_info));
}
for (auto& argument_type : node->argument_types) {
Visitor::Visit(argument_type);
auto type_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
current_info_.reset();
info.arg_types.push_back(std::move(type_info));
}
global_info_.AddFunctionDeclaration(node->name, std::move(info));
}
void FindSymbolsVisitor::Visit(FunctionDefinition* node) {
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];
}
if (was_in_statement) {
current_info_ = std::move(info);
} else {
global_info_.AddFunctionDeclaration(node->name, std::move(info));
is_in_statement = false;
}
}
void FindSymbolsVisitor::Visit(FunctionDefinitionStatement* node) {
is_in_statement = true;
info::FunctionDefinitionInfo info;
Visit(node->name.get());
auto name_info = std::move(
std::any_cast<info::SymbolDefinitionInfo>(current_info_));
current_info_.reset();
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());
for (size_t i = 0; i < definition->arguments.size(); ++i) {
info.argument_names[i] = definition->arguments[i].name;
}
info.params = std::move(name_info.params);
info.arg_names = std::move(name_info.arg_names);
info.expression = &node->value;
global_info_.AddFunctionDefinition(name_info.name, std::move(info));
global_info_.AddFunctionDefinition(definition->name, std::move(info));
is_in_statement = false;
}
void FindSymbolsVisitor::Visit(AliasTypeDefinition* node) { // TODO: unite with AliasDefinition
void FindSymbolsVisitor::Visit(TypeDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
Visit(node->type.get());
auto type_info = std::move(
std::any_cast<std::pair<std::string, std::vector<std::string>>>(current_info_));
current_info_.reset();
Visit(node->value.get());
auto value_info = std::move(std::any_cast<info::TypeUsageInfo>(current_info_));
current_info_.reset();
info::AliasTypeInfo alias_info;
alias_info.isAnotherType = true;
alias_info.params = std::move(type_info.second);
alias_info.value = std::move(value_info);
info.type = std::move(alias_info);
global_info_.AddType(type_info.first, std::move(info));
}
void FindSymbolsVisitor::Visit(TypeDefinition* node) {
info::TypeInfo info;
Visit(node->type.get());
auto type_info = std::move(
std::any_cast<info::SymbolDefinitionInfo>(current_info_));
current_info_.reset();
Visitor::Visit(node->value);
auto value_info = std::move(std::any_cast<info::AnyTypeVariant>(current_info_));
current_info_.reset();
auto definition = node->definition.get();
info::AnyTypeInfo any_type_info;
any_type_info.params = std::move(type_info.params);
any_type_info.arg_names = std::move(type_info.arg_names);
switch (value_info.index()) {
case 0:
any_type_info.info =
std::make_unique<info::VariantTypeInfo>(
std::move(std::get<info::VariantTypeInfo>(value_info)));
break;
case 1:
any_type_info.info =
std::make_unique<info::TupleTypeInfo>(
std::move(std::get<info::TupleTypeInfo>(value_info)));
break;
case 2:
any_type_info.info =
std::make_unique<info::BuiltInTypeInfo>(
std::move(std::get<info::BuiltInTypeInfo>(value_info)));
break;
default:
// error
break;
Visit(definition->type.get());
any_type_info.type = std::move(std::any_cast<info::ParameterInfo>(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_));
current_info_.reset();
}
any_type_info.value = &node->value;
std::string type = any_type_info.type.type;
info.type = std::move(any_type_info);
global_info_.AddType(type_info.name, std::move(info));
global_info_.AddType(type, std::move(info));
is_in_statement = false;
}
void FindSymbolsVisitor::Visit(TypeclassDefinition* node) {
void FindSymbolsVisitor::Visit(AbstractTypeDefinitionStatement* node) {
is_in_statement = true;
info::TypeInfo info;
info::AbstractTypeInfo abstract_type_info;
Visit(node->type.get());
abstract_type_info.type = std::move(std::any_cast<info::ParameterInfo>(current_info_));
current_info_.reset();
switch (node->modifier) {
case interpreter::AbstractTypeDefinitionStatement::Basic:
abstract_type_info.modifier = info::AbstractTypeInfo::Basic;
break;
case interpreter::AbstractTypeDefinitionStatement::Abstract:
abstract_type_info.modifier = info::AbstractTypeInfo::Abstract;
break;
}
std::string type = abstract_type_info.type.type;
info.type = std::move(abstract_type_info);
global_info_.AddType(type, std::move(info));
is_in_statement = false;
}
void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
is_in_statement = true;
info::TypeclassInfo info;
Visit(node->typeclass.get());
auto typeclass_info = std::move(
std::any_cast<info::SymbolDefinitionInfo>(current_info_));
current_info_.reset();
info.params = std::move(typeclass_info.params);
info.arg_names = std::move(typeclass_info.arg_names);
auto definition = node->definition.get();
for (auto& requirement : node->requirements) {
Visit(requirement.get());
auto requrement_info = std::move(std::any_cast<info::FunctionDeclarationInfo>(current_info_));
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.requirements.push_back(std::move(requrement_info));
}
global_info_.AddTypeclass(typeclass_info.name, std::move(info));
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_));
current_info_.reset();
}
global_info_.AddTypeclass(definition->type.get()->type, std::move(info));
is_in_statement = false;
}
// Definition parts
void FindSymbolsVisitor::Visit(DefinedName* node) {
info::SymbolDefinitionInfo info;
info.name = node->name;
for (auto& parameter : node->parameters) {
Visit(parameter.get());
auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
current_info_.reset();
info.params.push_back(std::move(param_info));
}
for (auto& argument : node->arguments) {
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));
}
current_info_ = std::move(info);
}
void FindSymbolsVisitor::Visit(DefinedAnnotatedName* node) { // TODO: remove
// Visit(&node->name);
if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
} else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
} else {
// no annotation
}
}
void FindSymbolsVisitor::Visit(DefinedType* node) {
info::SymbolDefinitionInfo info;
Visit(node->type.get());
info.name = /*...*/; // TODO
for (auto& parameter : node->parameters) {
Visit(parameter.get());
auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
current_info_.reset();
info.params.push_back(std::move(param_info));
}
for (auto& argument : node->arguments) {
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));
}
current_info_ = std::move(info);
}
void FindSymbolsVisitor::Visit(DefinedTypeclass* node) {
info::SymbolDefinitionInfo info;
Visit(node->typeclass.get());
info.name = /*...*/; // TODO
for (auto& parameter : node->parameters) {
Visit(parameter.get());
auto param_info = std::move(std::any_cast<info::ParameterInfo>(current_info_));
current_info_.reset();
info.params.push_back(std::move(param_info));
}
for (auto& argument : node->arguments) {
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));
}
current_info_ = std::move(info);
}
void FindSymbolsVisitor::Visit(DefinitionParameter* node) {
void FindSymbolsVisitor::Visit(AnyAnnotatedType* node) {
info::ParameterInfo info;
info.name = node->type;
for (auto& typeclass : node->typeclasses) {
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));
info.type = node->type;
info.typeclass_nodes.resize(node->typeclasses.size());
for (size_t i = 0; i < node->typeclasses.size(); ++i) {
info.typeclass_nodes[i] = &node->typeclasses[i];
}
current_info_ = std::move(info);
}
void FindSymbolsVisitor::Visit(DefinitionArgument* node) {
std::string info; // TODO: add type
info = node->name;
// for (auto& type : node->types) {
// Visit(type.get());
// 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. -----------------
// Name
// void FindSymbolsVisitor::Visit(NameSuperExpression* node) {
// for (auto& variable_namespace : node->namespaces) {
// Visitor::Visit(variable_namespace);
// }
// for (size_t i = 0; i < node->expressions.size(); ++i) {
// Visitor::Visit(node->expressions[i]);
// if (i + 1 < node->expressions.size()) {
// }
// }
// }
//
// void FindSymbolsVisitor::Visit(NameExpression* node) {
// for (auto& variable_namespace : node->namespaces) {
// Visitor::Visit(variable_namespace);
// }
// for (size_t i = 0; i < node->names.size(); ++i) {
// Visit(&node->names[i]);
// if (i + 1 < node->names.size()) {
// }
// }
// }
//
// void FindSymbolsVisitor::Visit(TupleName* node) {
// for (auto& name : node->names) {
// Visit(name.get());
// }
// }
//
// void FindSymbolsVisitor::Visit(VariantName* node) {
// for (auto& name : node->names) {
// Visit(name.get());
// }
// }
//
// void FindSymbolsVisitor::Visit(AnnotatedName* node) {
// Visit(&node->name);
// if (node->type.has_value()) {
// Visit(node->type.value().get());
// }
// }
// Type
void FindSymbolsVisitor::Visit(TupleType* node) {
info::TupleTypeInfo info;
if (node->type.has_value()) {
info.name = node->type.value();
}
for (auto& entity : node->entities) {
info.fields.emplace_back();
if (entity.first.has_value()) {
info.fields.back().first = entity.first.value();
}
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);
}
current_info_ = info::AnyTypeVariant(std::move(info));
}
void FindSymbolsVisitor::Visit(VariantType* node) {
info::VariantTypeInfo info;
if (node->type.has_value()) {
info.name = node->type.value();ParametrizedType
}
for (auto& constructor : node->constructors) {
if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
info.constructors.push_back(std::get<TypeIdentifierDefinition>(constructor));
} else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
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 {
// error
}
}
current_info_ = info::AnyTypeVariant(std::move(info));
}
void FindSymbolsVisitor::Visit(AnnotatedType* node) {
Visit(node->type_expression.get());
if (!node->annotations.empty()) {
}
for (auto& annotation : node->annotations) {
Visit(annotation.get());
}
}
void FindSymbolsVisitor::Visit(ParametrizedType* node) {
Visit(node->type_expression.get());
for (auto& parameter : node->parameters) {
Visitor::Visit(parameter);
}
}
void FindSymbolsVisitor::Visit(TypeExpression* node) {
for (auto& type_namespace : node->namespaces) {
Visitor::Visit(type_namespace);
}
Visit(&node->type);
}
// Typeclass
void FindSymbolsVisitor::Visit(AnnotatedTypeclass* node) {
Visit(node->typeclass_expression.get());
if (!node->annotations.empty()) {
}
for (auto& annotation : node->annotations) {
Visit(annotation.get());
}
}
void FindSymbolsVisitor::Visit(ParametrizedTypeclass* node) {
Visit(node->typeclass_expression.get());
for (auto& paramater : node->parameters) {
Visitor::Visit(paramater);
}
}
void FindSymbolsVisitor::Visit(TypeclassExpression* node) {
for (auto& typeclass_namespace : node->namespaces) {
Visitor::Visit(typeclass_namespace);
}
Visit(&node->typeclass);
}
} // namespace interpreter

183607
src/parser.c
View file

File diff suppressed because it is too large Load diff

17
src/print_visitor.cpp
View file

@ -247,8 +247,8 @@ void PrintVisitor::Visit(TypeDefinition* node) {
out_ << ' ';
}
void PrintVisitor::Visit(DefinitionParameter* node) {
out_ << "[DefinitionParameter ";
void PrintVisitor::Visit(AnyAnnotatedType* node) {
out_ << "[Annotated (Abstract) Type ";
Visit(&node->type);
out_ << ']';
if (!node->typeclasses.empty() > 0) {
@ -590,19 +590,6 @@ void PrintVisitor::Visit(VariantType* node) {
out_ << ')';
}
void PrintVisitor::Visit(AnnotatedType* node) {
out_ << "[AnnotatedType ";
Visit(node->type_expression.get());
out_ << ']';
if (!node->annotations.empty()) {
out_ << " : (";
for (auto& annotation : node->annotations) {
Visitor::Visit(annotation);
}
out_ << ')';
}
}
void PrintVisitor::Visit(ParametrizedType* node) {
out_ << "[ParametrizedType] (";
Visit(node->type_expression.get());