mirror of
https://codeberg.org/ProgramSnail/lang.git
synced 2025-12-26 08:48:45 +00:00
part of type checker, type heck result type
This commit is contained in:
ProgramSnail
parent
48c9e200be
commit
17ff590048
13 changed files with 1022 additions and 321 deletions
|
|
@ -25,111 +25,130 @@ build_expression(parser::ParseTree::Node parser_node,
|
|||
// --- flow control
|
||||
case tokens::Type::MATCH:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_match(parser_node, expression_storage, type_storage), is_scoped));
|
||||
case tokens::Type::CONDITION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_condition(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::LOOP:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_loop(parser_node, expression_storage, type_storage), is_scoped));
|
||||
// --- operators
|
||||
case tokens::Type::COMMA_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_comma_expression(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::OPERATOR_EXPRESSION:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_operator_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_operator_expression(
|
||||
parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
// --- containers
|
||||
case tokens::Type::BLOCK:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_block(parser_node, expression_storage, type_storage), is_scoped));
|
||||
case tokens::Type::ARRAY:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_array(parser_node, expression_storage, type_storage), is_scoped));
|
||||
// --- modifiers
|
||||
case tokens::Type::RETURN:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_return(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::NAME_DEFINITION:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_name_definition(parser_node), is_scoped));
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_name_definition(parser_node), is_scoped));
|
||||
case tokens::Type::ARRAY_ACCESS:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_array_access(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::TUPLE_ACCESS:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_tuple_access(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::LOOP_CONTROL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_loop_control(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_loop_control(parser_node), is_scoped));
|
||||
case tokens::Type::REFERENCE_EXPRESSION:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_reference_expression(
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_reference_expression(
|
||||
parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::SUFFIX_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_suffix_expression(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
// --- other
|
||||
case tokens::Type::NAME_EXPRESSION:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_name_expression(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::ARGUMENT_NAME_IDENTIFIER:
|
||||
case tokens::Type::SIMPLE_NAME_IDENTIFIER:
|
||||
case tokens::Type::PLACEHOLDER:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(nodes::NameExpression(build_node(parser_node),
|
||||
nodes::Expression(build_node(parser_node),
|
||||
nodes::NameExpression(build_node(parser_node),
|
||||
build_identifier(parser_node)),
|
||||
is_scoped));
|
||||
case tokens::Type::CONSTRUCTOR:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_constructor(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
case tokens::Type::LAMBDA:
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node),
|
||||
build_lambda(parser_node, expression_storage, type_storage),
|
||||
is_scoped));
|
||||
// --- literals
|
||||
case tokens::Type::FLOAT_NUMBER_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_float_number_literal(parser_node), is_scoped));
|
||||
nodes::Expression(build_node(parser_node),
|
||||
build_float_number_literal(parser_node), is_scoped));
|
||||
case tokens::Type::NUMBER_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_number_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_number_literal(parser_node), is_scoped));
|
||||
case tokens::Type::STRING_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_string_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_string_literal(parser_node), is_scoped));
|
||||
case tokens::Type::CHAR_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_char_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_char_literal(parser_node), is_scoped));
|
||||
case tokens::Type::BOOL_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_bool_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_bool_literal(parser_node), is_scoped));
|
||||
case tokens::Type::UNIT_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_unit_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_unit_literal(parser_node), is_scoped));
|
||||
case tokens::Type::NULL_LITERAL:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_null_literal(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_null_literal(parser_node), is_scoped));
|
||||
case tokens::Type::EXTRA:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_extra(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_extra(parser_node), is_scoped));
|
||||
case tokens::Type::EMPTY_LINES:
|
||||
return expression_storage.add_expression(
|
||||
nodes::Expression(build_empty_lines(parser_node), is_scoped));
|
||||
return expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node), build_empty_lines(parser_node), is_scoped));
|
||||
default:
|
||||
error_handling::handle_parsing_error("Unexprected expression node type",
|
||||
parser_node);
|
||||
}
|
||||
|
||||
error_handling::handle_general_error("Unreachable");
|
||||
exit(1); // unreachable
|
||||
}
|
||||
|
|
@ -392,6 +411,7 @@ nodes::Access build_tuple_access(parser::ParseTree::Node parser_node,
|
|||
build_expression(parser_node.nth_named_child(0), expression_storage,
|
||||
type_storage),
|
||||
expression_storage.add_expression(nodes::Expression(
|
||||
build_node(parser_node.nth_named_child(1)),
|
||||
build_number_literal(parser_node.nth_named_child(1)), false)));
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -53,7 +53,8 @@ build_statement(parser::ParseTree::Node parser_node,
|
|||
|
||||
switch (type) {
|
||||
case tokens::Type::IMPORT:
|
||||
statement = nodes::Statement(build_import(parser_node));
|
||||
statement =
|
||||
nodes::Statement(build_node(parser_node), build_import(parser_node));
|
||||
statement_name = *statement.value()
|
||||
.get<nodes::Import>()
|
||||
.value()
|
||||
|
|
@ -62,7 +63,8 @@ build_statement(parser::ParseTree::Node parser_node,
|
|||
break;
|
||||
case tokens::Type::TYPE_DEFINITION:
|
||||
statement =
|
||||
nodes::Statement(build_type_definition(parser_node, type_storage));
|
||||
nodes::Statement(build_node(parser_node),
|
||||
build_type_definition(parser_node, type_storage));
|
||||
last_defined_type_name =
|
||||
*statement.value().get<nodes::TypeDefinition>().value()->get_name();
|
||||
statement_name = *statement.value()
|
||||
|
|
@ -72,8 +74,10 @@ build_statement(parser::ParseTree::Node parser_node,
|
|||
->get();
|
||||
break;
|
||||
case tokens::Type::FUNCTION_DEFINITION:
|
||||
statement = nodes::Statement(build_function_definition(
|
||||
parser_node, last_defined_type_name, expression_storage, type_storage));
|
||||
statement = nodes::Statement(
|
||||
build_node(parser_node),
|
||||
build_function_definition(parser_node, last_defined_type_name,
|
||||
expression_storage, type_storage));
|
||||
statement_name = *statement.value()
|
||||
.get<nodes::FunctionDefinition>()
|
||||
.value()
|
||||
|
|
@ -81,10 +85,12 @@ build_statement(parser::ParseTree::Node parser_node,
|
|||
->get();
|
||||
break;
|
||||
case tokens::Type::EXTRA:
|
||||
statement = nodes::Statement(build_extra(parser_node));
|
||||
statement =
|
||||
nodes::Statement(build_node(parser_node), build_extra(parser_node));
|
||||
break;
|
||||
case tokens::Type::EMPTY_LINES:
|
||||
statement = nodes::Statement(build_empty_lines(parser_node));
|
||||
statement = nodes::Statement(build_node(parser_node),
|
||||
build_empty_lines(parser_node));
|
||||
break;
|
||||
default:
|
||||
error_handling::handle_parsing_error("Unexprected statement node type",
|
||||
|
|
@ -315,7 +321,7 @@ nodes::FunctionDefinition build_function_definition(
|
|||
return_modifier = build_modifier(current_node);
|
||||
|
||||
// only optional, result allowed
|
||||
if (!utils::is_suffix_modifier(return_modifier)) {
|
||||
if (!nodes::utils::is_suffix_modifier(return_modifier)) {
|
||||
return_modifier = nodes::Modifier::NONE;
|
||||
}
|
||||
}
|
||||
|
|
@ -341,7 +347,7 @@ nodes::FunctionDefinition build_function_definition(
|
|||
last_before_modifier = build_modifier(maybe_reference_node);
|
||||
|
||||
// only out, in, ref allowed
|
||||
if (utils::is_suffix_modifier(last_before_modifier)) {
|
||||
if (nodes::utils::is_suffix_modifier(last_before_modifier)) {
|
||||
last_before_modifier = nodes::Modifier::NONE;
|
||||
}
|
||||
}
|
||||
|
|
@ -357,7 +363,7 @@ nodes::FunctionDefinition build_function_definition(
|
|||
last_after_modifier = build_modifier(maybe_reference_node);
|
||||
|
||||
// only optional, result allowed
|
||||
if (!utils::is_suffix_modifier(last_after_modifier)) {
|
||||
if (!nodes::utils::is_suffix_modifier(last_after_modifier)) {
|
||||
last_after_modifier = nodes::Modifier::NONE;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ nodes::TypeProxy build_type(parser::ParseTree::Node parser_node,
|
|||
nodes::TypeStorage &type_storage) {
|
||||
tokens::Type type = tokens::string_to_type(parser_node.get_type());
|
||||
|
||||
// TODO
|
||||
// TODO: for better formatted printing
|
||||
// auto maybe_parenthesis = parser_node.previous_sibling();
|
||||
// bool is_scoped =
|
||||
// (!maybe_parenthesis.is_null() && !maybe_parenthesis.is_named() &&
|
||||
|
|
@ -39,10 +39,9 @@ nodes::TypeProxy build_type(parser::ParseTree::Node parser_node,
|
|||
exit(1); // unreachable
|
||||
}
|
||||
|
||||
nodes::TypeProxy
|
||||
build_buildin_container_type(parser::ParseTree::Node parser_node,
|
||||
nodes::TypeStorage &type_storage,
|
||||
const std::string &type_name) {
|
||||
nodes::TypeProxy build_container_type(parser::ParseTree::Node parser_node,
|
||||
nodes::TypeStorage &type_storage,
|
||||
builtin::types::Type container) {
|
||||
std::vector<nodes::TypeProxy> parameters;
|
||||
|
||||
std::optional<std::string> current_annotation;
|
||||
|
|
@ -61,39 +60,31 @@ build_buildin_container_type(parser::ParseTree::Node parser_node,
|
|||
current_node = current_node.next_named_sibling();
|
||||
}
|
||||
|
||||
return type_storage.add_type(
|
||||
nodes::Type(build_node(parser_node),
|
||||
nodes::Identifier(build_node(parser_node),
|
||||
nodes::Identifier::SIMPLE_TYPE, type_name),
|
||||
std::move(parameters), false));
|
||||
return type_storage.add_container_of(std::move(parameters), container,
|
||||
build_node(parser_node));
|
||||
}
|
||||
|
||||
// '|'? annotation? type ('|' annotation? type)+
|
||||
nodes::TypeProxy build_variant_type(parser::ParseTree::Node parser_node,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_buildin_container_type(parser_node, type_storage,
|
||||
builtin::VARIANT_IDENTIFIER);
|
||||
return build_container_type(parser_node, type_storage,
|
||||
builtin::types::Type::VARIANT);
|
||||
}
|
||||
|
||||
// '&'? annotation? type ('&' annotation? type)+
|
||||
nodes::TypeProxy build_tuple_type(parser::ParseTree::Node parser_node,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
return build_buildin_container_type(parser_node, type_storage,
|
||||
builtin::TUPLE_IDENTIFIER);
|
||||
return build_container_type(parser_node, type_storage,
|
||||
builtin::types::Type::TUPLE);
|
||||
}
|
||||
|
||||
// '[[' type ']]'
|
||||
nodes::TypeProxy build_array_type(parser::ParseTree::Node parser_node,
|
||||
nodes::TypeStorage &type_storage) {
|
||||
std::vector<nodes::TypeProxy> parameters;
|
||||
parameters.push_back(
|
||||
build_type(parser_node.nth_named_child(0), type_storage));
|
||||
|
||||
return type_storage.add_type(nodes::Type(
|
||||
build_node(parser_node),
|
||||
nodes::Identifier(build_node(parser_node), nodes::Identifier::SIMPLE_TYPE,
|
||||
builtin::ARRAY_IDENTIFIER),
|
||||
std::move(parameters), false));
|
||||
return type_storage.add_array_of(
|
||||
build_type(parser_node.nth_named_child(0), type_storage),
|
||||
build_node(parser_node));
|
||||
}
|
||||
|
||||
// '^' type
|
||||
|
|
@ -119,10 +110,10 @@ nodes::TypeProxy build_modified_type(parser::ParseTree::Node parser_node,
|
|||
|
||||
switch (modifier) {
|
||||
case nodes::Modifier::OPTIONAL:
|
||||
identifier = builtin::OPTIONAL_IDENTIFIER;
|
||||
identifier = builtin::types::OPTIONAL_IDENTIFIER;
|
||||
break;
|
||||
case nodes::Modifier::RESULT:
|
||||
identifier = builtin::RESULT_IDENTIFIER;
|
||||
identifier = builtin::types::RESULT_IDENTIFIER;
|
||||
break;
|
||||
default:
|
||||
error_handling::handle_parsing_error(
|
||||
|
|
@ -131,8 +122,7 @@ nodes::TypeProxy build_modified_type(parser::ParseTree::Node parser_node,
|
|||
}
|
||||
|
||||
return type_storage.add_type(
|
||||
nodes::Type(build_node(parser_node),
|
||||
nodes::Identifier(build_node(parser_node),
|
||||
nodes::Type(nodes::Identifier(build_node(parser_node),
|
||||
nodes::Identifier::SIMPLE_TYPE, identifier),
|
||||
std::move(parameters), false));
|
||||
}
|
||||
|
|
@ -150,9 +140,8 @@ nodes::TypeProxy build_simple_type(parser::ParseTree::Node parser_node,
|
|||
current_node = current_node.next_named_sibling();
|
||||
}
|
||||
|
||||
return type_storage.add_type(nodes::Type(build_node(parser_node),
|
||||
build_identifier(name_node),
|
||||
std::move(parameters), false));
|
||||
return type_storage.add_type(
|
||||
nodes::Type(build_identifier(name_node), std::move(parameters), false));
|
||||
}
|
||||
|
||||
} // namespace builders
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue