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

part of type_check_visitor done

Browse source
This commit is contained in:
ProgramSnail 2023-04-22 19:30:16 +03:00
parent 6fc91aafa0
commit 656f58bcde
14 changed files with 891 additions and 539 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/global_info.hpp
View file

@ -64,6 +64,10 @@ public:
return global_info_.GetAbstractTypeGraph();
}
GlobalInfo* GetGlobalInfo() {
return &global_info_;
}
const std::vector<std::string>& GetCurrentPath() {
return current_path_;
}

4
include/interpreter_tree.hpp
View file

@ -261,7 +261,6 @@ struct Namespace {
std::unique_ptr<Sources> scope;
std::optional<utils::IdType> type_id_;
std::optional<info::type::Type> variable_type_;
};
struct Partition {
@ -471,6 +470,9 @@ struct LambdaFunction {
std::vector<std::unique_ptr<AnnotatedAbstractType>> parameters;
std::vector<ExtendedName> arguments;
Expression expression;
std::vector<utils::IdType> argument_graph_ids_;
utils::IdType return_type_graph_id_;
};
struct ArrayExpression {

63
include/link_symbols_visitor.hpp
View file

@ -41,66 +41,65 @@ private:
void Visit(FunctionDefinition* node) override;
void Visit(TypeDefinition* node) override;
void Visit(AnyAnnotatedType* node) override;
// // void Visit(AnyAnnotatedType* node) override;
// Flow control -----------------
void Visit(MatchCase* node) override;
void Visit(Match* node) override;
void Visit(Condition* node) override;
void Visit(DoWhileLoop* node) override;
void Visit(WhileLoop* node) override;
void Visit(ForLoop* node) override;
void Visit(LoopLoop* node) override;
// // void Visit(MatchCase* node) override;
// // void Visit(Match* node) override;
// // void Visit(Condition* node) override;
// // void Visit(DoWhileLoop* node) override;
// // void Visit(WhileLoop* node) override;
// // void Visit(ForLoop* node) override;
// // void Visit(LoopLoop* node) override;
// Statements, expressions, blocks, etc. -----------------
void Visit(Block* node) override;
void Visit(ScopedStatement* node) override;
// // void Visit(Block* node) override;
// // void Visit(ScopedStatement* node) override;
// Operators
void Visit(BinaryOperatorExpression* node) override;
void Visit(UnaryOperatorExpression* node) override;
void Visit(ReferenceExpression* node) override;
void Visit(AccessExpression* node) override;
// // void Visit(BinaryOperatorExpression* node) override;
// // void Visit(UnaryOperatorExpression* node) override;
// // void Visit(ReferenceExpression* node) override;
// // void Visit(AccessExpression* node) override;
// Simple Expressions
void Visit(FunctionCallExpression* node) override;
// // void Visit(FunctionCallExpression* node) override;
void Visit(TupleExpression* node) override;
void Visit(VariantExpression* node) override;
void Visit(ReturnExpression* node) override;
void Visit(TypeConstructor* node) override;
// // void Visit(TupleExpression* node) override;
// // void Visit(VariantExpression* node) override;
// // void Visit(ReturnExpression* node) override;
// // void Visit(TypeConstructor* node) override;
void Visit(LambdaFunction* node) override;
void Visit(ArrayExpression* node) override;
// // void Visit(ArrayExpression* node) override;
void Visit(LoopControlExpression& node) override; // enum
// // void Visit(LoopControlExpression& node) override; // enum
// Name
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(FunctionType* node) override;
void Visit(TupleType* node) override;
void Visit(VariantType* node) override;
void Visit(ParametrizedType* 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;
// // void Visit(ExtendedScopedAnyType* node) override;
// Typeclass
void Visit(ParametrizedTypeclass* node) override;
// // void Visit(ParametrizedTypeclass* node) override;
void Visit(TypeclassExpression* node) override;
// Identifiers, constants, etc. -----------------

8
include/symbols_info.hpp
View file

@ -85,17 +85,19 @@ 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::SuperExpression* expression = nullptr;
interpreter::tokens::FunctionDefinitionStatement* node = nullptr;
};
struct FunctionInfo {
FunctionDeclarationInfo declaration;
FunctionDefinitionInfo definition;
size_t argument_count = 0;
std::optional<FunctionDeclarationInfo> declaration;
std::optional<FunctionDefinitionInfo> definition;
};
struct TypeclassInfo {

1
include/type_check_visitor.hpp
View file

@ -117,6 +117,7 @@ private:
info::TypeInfoContextManager context_manager_;
utils::IdType current_type_;
std::optional<utils::IdType> returned_type_;
};
} // namespace interpreter

42
include/type_info_contexts.hpp
View file

@ -23,20 +23,21 @@ public:
return types_[type_id];
}
// void AddTypeRequirement(utils::IdType type, utils::IdType requrement); // TODO
void AddTypeRequirement(utils::IdType type, utils::IdType requrement) {} // TODO
void EqualTypes(utils::IdType first_type, utils::IdType second_type) {} // TODO
void CallFunction(const std::vector<std::string>& names,
const std::vector<utils::IdType>& argument_types) {
if (names.size() != argument_types.size()) {
// error
}
contexts_.emplace_back(true);
for (size_t i = 0; i < names.size(); ++i) {
DefineVariable(names[i], argument_types[i]);
}
}
// void CallFunction(const std::vector<std::string>& names,
// const std::vector<utils::IdType>& argument_types) {
// if (names.size() != argument_types.size()) {
// // error
// }
//
// contexts_.emplace_back(true);
//
// for (size_t i = 0; i < names.size(); ++i) {
// DefineVariable(names[i], argument_types[i]);
// }
// }
void EnterContext() {
contexts_.emplace_back(false);
@ -59,6 +60,15 @@ public:
return contexts_.back().DefineVariable(name, type_id);
}
bool RemoveVariable(const std::string& name) {
for (ssize_t i = (ssize_t)contexts_.size() - 1; i >= 0; --i) {
if (contexts_[i].RemoveVariable(name)) {
return true;
}
}
return false;
}
void EnterVariableContext(const std::string& name,
utils::IdType type_id) { // for variable namespaces, for loops
contexts_.push_back(false);
@ -67,7 +77,7 @@ public:
}
std::optional<utils::IdType> GetVariableType(const std::string& name) {
for (ssize_t i = contexts_.size() - 1; i >= 0; --i) {
for (ssize_t i = (ssize_t)contexts_.size() - 1; i >= 0; --i) {
auto maybe_type = contexts_[i].GetVariableType(name);
if (maybe_type.has_value()) {
return maybe_type.value();
@ -89,6 +99,10 @@ private:
return true;
}
bool RemoveVariable(const std::string& name) {
return variables_.erase(name);
}
std::optional<utils::IdType> GetVariableType(const std::string& name) {
auto variable_iter = variables_.find(name);

38
include/types_info.hpp
View file

@ -6,7 +6,6 @@
#include <memory>
// for clangd
#include "error_handling.hpp"
#include "utils.hpp"
namespace info::type {
@ -37,39 +36,14 @@ struct TupleType { //
};
struct VariantType {
static VariantType MakeOptional(const std::variant<std::string, TupleType>& option) {
if (std::holds_alternative<std::string>(option)) {
return MakeOptional(option);
} else if (std::holds_alternative<TupleType>(option)) {
return MakeOptional(std::get<TupleType>(option));
} else {
error_handling::HandleInternalError("Can't construct optional from variant", "info::type::VariantType::MakeOptional");
}
}
static VariantType MakeOptional(TupleType option) { // TODO
VariantType type;
type.type = option.type;
option.type = "\'Some";
type.constructors.emplace_back(option);
type.constructors.emplace_back("\'None");
return type;
}
static VariantType MakeOptional(std::string& option) { // TODO
VariantType type;
type.type = option;
type.constructors.emplace_back("\'Some");
type.constructors.emplace_back("\'None");
return type;
}
std::optional<std::string> type;
std::vector<std::variant<std::string, TupleType>> constructors;
};
struct OptionalType {
std::optional<utils::IdType> type; // Can be empty (Some or None)
};
struct ReferenceToType {
std::vector<utils::ReferenceType> references;
utils::IdType type;
@ -77,10 +51,12 @@ struct ReferenceToType {
struct FunctionType {
std::vector<utils::IdType> argument_types;
utils::IdType return_type;
};
struct ArrayType {
std::vector<utils::IdType> element_types;
size_t size; // ?? = 0 for dynamic ??
std::optional<utils::IdType> elements_type;
};
using Type = std::variant<AbstractType,

108
include/visitor.hpp
View file

@ -16,42 +16,42 @@ public:
protected:
// Sources -----------------
virtual void Visit(SourceFile* node) {}
virtual void Visit(Sources* node) {}
virtual void Visit(SourceFile* node);
virtual void Visit(Sources* node);
// Namespaces, partitions -----------------
virtual void Visit(Partition* node) {}
virtual void Visit(Namespace* node) {}
virtual void Visit(Partition* node);
virtual void Visit(Namespace* node);
// Definitions -----------------
virtual void Visit(ImportStatement* node) {}
virtual void Visit(AliasDefinitionStatement* node) {}
virtual void Visit(VariableDefinitionStatement* node) {}
virtual void Visit(FunctionDeclaration* node) {}
virtual void Visit(FunctionDefinitionStatement* node) {}
virtual void Visit(TypeDefinitionStatement* node) {}
virtual void Visit(AbstractTypeDefinitionStatement* node) {}
virtual void Visit(TypeclassDefinitionStatement* node) {}
virtual void Visit(ImportStatement* node);
virtual void Visit(AliasDefinitionStatement* node);
virtual void Visit(VariableDefinitionStatement* node);
virtual void Visit(FunctionDeclaration* node);
virtual void Visit(FunctionDefinitionStatement* node);
virtual void Visit(TypeDefinitionStatement* node);
virtual void Visit(AbstractTypeDefinitionStatement* node);
virtual void Visit(TypeclassDefinitionStatement* node);
virtual void Visit(SourceStatement& node); // variant
// Definition parts
virtual void Visit(FunctionDefinition* node) {}
virtual void Visit(TypeDefinition* node) {}
virtual void Visit(AnyAnnotatedType* node) {}
virtual void Visit(FunctionDefinition* node);
virtual void Visit(TypeDefinition* node);
virtual void Visit(AnyAnnotatedType* node);
// Flow control -----------------
virtual void Visit(MatchCase* node) {}
virtual void Visit(Match* node) {}
virtual void Visit(Condition* node) {}
virtual void Visit(DoWhileLoop* node) {}
virtual void Visit(WhileLoop* node) {}
virtual void Visit(ForLoop* node) {}
virtual void Visit(LoopLoop* node) {}
virtual void Visit(MatchCase* node);
virtual void Visit(Match* node);
virtual void Visit(Condition* node);
virtual void Visit(DoWhileLoop* node);
virtual void Visit(WhileLoop* node);
virtual void Visit(ForLoop* node);
virtual void Visit(LoopLoop* node);
virtual void Visit(FlowControl& node); // variant
@ -59,7 +59,7 @@ protected:
virtual void Visit(BlockStatement& node); // variant
virtual void Visit(Block* node) {}
virtual void Visit(Block* node);
virtual void Visit(SubExpressionToken& node); // variant
virtual void Visit(SubExpression& node); // variant
@ -67,36 +67,36 @@ protected:
virtual void Visit(Expression& node); // variant
virtual void Visit(SuperExpression& node); // variant
virtual void Visit(ScopedStatement* node) {}
virtual void Visit(ScopedStatement* node);
// Operators
virtual void Visit(BinaryOperatorExpression* node) {}
virtual void Visit(UnaryOperatorExpression* node) {}
virtual void Visit(ReferenceExpression* node) {}
virtual void Visit(AccessExpression* node) {}
virtual void Visit(BinaryOperatorExpression* node);
virtual void Visit(UnaryOperatorExpression* node);
virtual void Visit(ReferenceExpression* node);
virtual void Visit(AccessExpression* node);
// Simple Expressions
virtual void Visit(FunctionCallExpression* node) {}
virtual void Visit(FunctionCallExpression* node);
virtual void Visit(FunctionArgument& node); // variant
virtual void Visit(TupleExpression* node) {}
virtual void Visit(VariantExpression* node) {}
virtual void Visit(ReturnExpression* node) {}
virtual void Visit(TypeConstructor* node) {}
virtual void Visit(LambdaFunction* node) {}
virtual void Visit(ArrayExpression* node) {}
virtual void Visit(TupleExpression* node);
virtual void Visit(VariantExpression* node);
virtual void Visit(ReturnExpression* node);
virtual void Visit(TypeConstructor* node);
virtual void Visit(LambdaFunction* node);
virtual void Visit(ArrayExpression* node);
virtual void Visit(LoopControlExpression& node) {} // enum
virtual void Visit(LoopControlExpression& node); // enum
// Name
virtual void Visit(NameExpression* node) {}
virtual void Visit(TupleName* node) {}
virtual void Visit(VariantName* node) {}
virtual void Visit(AnnotatedName* node) {}
virtual void Visit(NameExpression* node);
virtual void Visit(TupleName* node);
virtual void Visit(VariantName* node);
virtual void Visit(AnnotatedName* node);
virtual void Visit(AnyName& node); // variant
@ -104,20 +104,20 @@ protected:
// Type
virtual void Visit(FunctionType* node) {}
virtual void Visit(TupleType* node) {}
virtual void Visit(VariantType* node) {}
virtual void Visit(ParametrizedType* node) {}
virtual void Visit(TypeExpression* node) {}
virtual void Visit(FunctionType* node);
virtual void Visit(TupleType* node);
virtual void Visit(VariantType* node);
virtual void Visit(ParametrizedType* node);
virtual void Visit(TypeExpression* node);
virtual void Visit(AnyType& node); // variant
virtual void Visit(ExtendedScopedAnyType* node) {}
virtual void Visit(ExtendedScopedAnyType* node);
// Typeclass
virtual void Visit(ParametrizedTypeclass* node) {}
virtual void Visit(TypeclassExpression* node) {}
virtual void Visit(ParametrizedTypeclass* node);
virtual void Visit(TypeclassExpression* node);
virtual void Visit(TypeclassUsage& node); // variant
@ -128,14 +128,14 @@ protected:
// Identifiers, constants, etc. -----------------
virtual void Visit(ExtendedName* node) {}
virtual void Visit(ExtendedName* node);
virtual void Visit(AnyIdentifier* node) {} // std::string
virtual void Visit(AnyIdentifier* node); // std::string
virtual void Visit(FloatNumberLiteral* node) {}
virtual void Visit(NumberLiteral* node) {}
virtual void Visit(StringLiteral* node) {}
virtual void Visit(CharLiteral* node) {}
virtual void Visit(FloatNumberLiteral* node);
virtual void Visit(NumberLiteral* node);
virtual void Visit(StringLiteral* node);
virtual void Visit(CharLiteral* node);
virtual void Visit(Literal& node); // variant
};