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

fixes, new examples

Browse source
This commit is contained in:
ProgramSnail 2023-05-23 11:54:15 +03:00
parent 823fa30fa8
commit 7f4266821c
15 changed files with 322 additions and 74 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/interpreter_tree.hpp
View file

@ -498,7 +498,7 @@ struct ReferenceExpression {
BaseNode base;
utils::ReferenceModifier reference;
std::unique_ptr<ScopedStatement> expression;
SubExpressionToken expression;
};
struct AccessExpression {

20
include/type_check_visitor.hpp
View file

@ -210,7 +210,10 @@ private:
}
void VisitDefinedType(info::definition::AnyType* defined_type,
const std::unordered_map<std::string, utils::IdType>& context) {
const std::unordered_map<std::string, utils::IdType>& context,
utils::ValueType modifier) {
context_manager_.EnterContext();
AddTypeParameterLocalTypes(defined_type);
Visitor::Visit(defined_type->node->value);
current_type_ = TypeInContext(current_type_, context);
current_type_ =
@ -218,7 +221,20 @@ private:
current_type_,
defined_type->modifier,
context_manager_.GetValueManager()),
utils::ValueType::Tmp);
modifier);
context_manager_.ExitContext();
}
void AddTypeParameterLocalTypes(info::definition::AnyType* type_info) {
for (auto& parameter : type_info->node->definition->parameters) {
context_manager_.DefineLocalType(
parameter->type,
context_manager_.AddValue(
info::type::AbstractType(utils::AbstractTypeModifier::Abstract,
parameter->graph_id_,
typeclass_graph_),
utils::ValueType::Tmp));
}
}
private:

24
include/types.hpp
View file

@ -43,7 +43,7 @@ public:
return graph_id == graph_id_ || typeclass_graph_.GetDependenciesSet(graph_id_).count(graph_id) != 0;
}
std::string ToString() {
std::string ToString() const {
return "Abstract " + std::to_string(graph_id_);
}
private:
@ -81,7 +81,7 @@ public:
return class_modifier_;
}
std::string ToString() {
std::string ToString() const {
return "Defined";
}
private:
@ -178,7 +178,7 @@ public:
return fields_;
}
std::string ToString();
std::string ToString() const;
private:
std::optional<std::string> name_;
std::vector<std::pair<std::optional<std::string>, utils::IdType>> fields_;
@ -209,7 +209,7 @@ public:
current_constructor_ = constructor;
}
std::string ToString();
std::string ToString() const;
private:
std::optional<std::string> name_;
std::vector<TupleType> constructors_;
@ -231,7 +231,7 @@ public:
std::optional<utils::IdType> GetFieldType(const std::string& name,
const std::unordered_set<utils::IdType>& type_namespaces) const;
std::string ToString();
std::string ToString() const;
private:
utils::IdType type_;
TypeManager* type_manager_ = nullptr;
@ -243,7 +243,11 @@ public:
ReferenceToType(const std::vector<utils::ReferenceModifier>& references,
utils::IdType type,
TypeManager* type_manager)
: references_(references), type_(type), type_manager_(type_manager) {}
: references_(references), type_(type), type_manager_(type_manager) {
if (references.empty()) {
error_handling::HandleInternalError("ReferenceToType with 0 references", "Type.ReferenceToType", std::nullopt);
}
}
std::optional<utils::IdType> InContext(const std::unordered_map<std::string, utils::IdType>& context);
bool Same(const ReferenceToType& type) const;
@ -253,7 +257,7 @@ public:
std::optional<utils::IdType> GetFieldType(const std::string& name,
const std::unordered_set<utils::IdType>& type_namespaces) const;
std::string ToString();
std::string ToString() const;
private:
std::vector<utils::ReferenceModifier> references_;
utils::IdType type_;
@ -278,7 +282,7 @@ public:
std::optional<utils::IdType> GetFieldType(const std::string& name,
const std::unordered_set<utils::IdType>& type_namespaces) const;
std::string ToString();
std::string ToString() const;
private:
std::vector<utils::IdType> argument_types_;
utils::IdType return_type_;
@ -305,7 +309,7 @@ public:
return elements_type_;
}
std::string ToString();
std::string ToString() const;
private:
size_t size_; // = 0 for dynamic
utils::IdType elements_type_;
@ -339,7 +343,7 @@ public:
return type_;
}
std::string ToString();
std::string ToString() const;
private:
std::variant<AbstractType,
DefinedType,

2
lang-parser

@ -1 +1 @@
Subproject commit 5346d008497d93d30db4933dc3744b3de35cebf8
Subproject commit e4696019cf4ec08e4d2c707297887ed9bc359499

6
src/build_visitor.cpp
View file

@ -924,8 +924,7 @@ void BuildVisitor::Visit(ReferenceExpression* node) {
}
current_node_ = parse_node.ChildByFieldName("expression");
node->expression = std::make_unique<ScopedStatement>();
Visit(node->expression.get());
Visit(node->expression);
current_node_ = parse_node;
}
@ -1053,7 +1052,8 @@ void BuildVisitor::Visit(TypeConstructorParameter* node) {
size_t child_count = parse_node.NamedChildCount();
if (child_count > 1) {
node->name = parse_node.ChildByFieldName("name").GetValue();
current_node_ = parse_node.ChildByFieldName("name");
node->name = current_node_.GetValue();
std::string assignment_modifier = current_node_.NextSibling().GetValue();
if (assignment_modifier == "=") {

4
src/execute_visitor.cpp
View file

@ -386,7 +386,7 @@ void ExecuteVisitor::Visit(LoopControlExpression& node) {
void ExecuteVisitor::Visit(ReferenceExpression* node) {
// TODO: check, that there is no references to "Tmp"??
Visit(node->expression.get());
Visitor::Visit(node->expression);
utils::ValueType value_type = context_manager_.GetValueType(current_value_);
@ -748,7 +748,7 @@ void ExecuteVisitor::Visit(TupleName* node) {
std::optional<info::value::TupleValue*> maybe_tuple_value = context_manager_.GetValue<info::value::TupleValue>(value);
if (maybe_tuple_value.has_value()) {
if (!maybe_tuple_value.has_value()) {
error_handling::HandleRuntimeError("Mismatched value types in tuple variable definition", node->base);
}

20
src/main.cpp
View file

@ -59,9 +59,17 @@ int main(int argc, char** argv) { // TODO, only test version
// std::cout << "\n---------------------------------- Untyped -------------------------------------\n\n";
// print_visitor.VisitSourceFile(source_file.get());
find_symbols_visitor.VisitSourceFile(source_file.get());
link_symbols_visitor.VisitSourceFile(source_file.get());
type_check_visitor.VisitSourceFile(source_file.get());
try {
find_symbols_visitor.VisitSourceFile(source_file.get());
} catch (...) { error_handling::HandleInternalError("find_symbols_visitor exception", "main", std::nullopt); }
try {
link_symbols_visitor.VisitSourceFile(source_file.get());
} catch (...) { error_handling::HandleInternalError("link_symbols_visitor exception", "main", std::nullopt); }
try {
type_check_visitor.VisitSourceFile(source_file.get());
} catch (...) { error_handling::HandleInternalError("type_check_visitor exception", "main", std::nullopt); }
std::optional<utils::IdType> maybe_main_partition_id = global_info.FindPartition({"main"});
@ -72,13 +80,15 @@ int main(int argc, char** argv) { // TODO, only test version
const info::GlobalInfo::PartitionInfo& main_partition =
global_info.GetPartitionInfo(maybe_main_partition_id.value());
std::cout << "\n---------------------------------- Execution -------------------------------------\n\n";
// std::cout << "\n---------------------------------- Execution -------------------------------------\n\n";
interpreter::ExecuteVisitor execute_visitor(global_info,
type_context_manager,
context_manager);
execute_visitor.ExecutePartition(main_partition.node);
try {
execute_visitor.ExecutePartition(main_partition.node);
} catch (...) { error_handling::HandleInternalError("execute_visitor exception", "main", std::nullopt); }
// std::cout << "\n---------------------------------- Typed -------------------------------------\n\n";
// typed_print_visitor.VisitSourceFile(source_file.get());

2
src/print_visitor.cpp
View file

@ -398,7 +398,7 @@ void PrintVisitor::Visit(ReferenceExpression* node) {
break;
}
out_ << "] (";
Visit(node->expression.get());
Visitor::Visit(node->expression);
out_ << ')';
}

36
src/type_check_visitor.cpp
View file

@ -58,13 +58,11 @@ void TypeCheckVisitor::Visit(Namespace* node) {
info::definition::AnyType* type_info = maybe_type_info.value();
Visitor::Visit(type_info->node->value);
utils::IdType type = context_manager_.AddValue(
info::type::DefinedType(node->link_type_id_.value(),
current_type_,
type_info->modifier,
context_manager_.GetValueManager()),
ClassInternalsModifierToValueType(node->modifier));
// make parameter local types
VisitDefinedType(type_info, {}, ClassInternalsModifierToValueType(node->modifier));
utils::IdType type = current_type_;
if (node->modifier != utils::ClassInternalsModifier::Static) {
context_manager_.DefineVariable(utils::ClassInternalVarName, type);
@ -248,7 +246,9 @@ void TypeCheckVisitor::Visit(FunctionDefinitionStatement* node) {
if (!returned_type_.has_value()) {
returned_type_ = current_type_;
}
if (!context_manager_.EqualValues(returned_type, returned_type_.value())) {
// error_handling::DebugPrint(context_manager_.GetAnyValue(returned_type)->ToString() + " : " + context_manager_.GetAnyValue(returned_type_.value())->ToString());
error_handling::HandleTypecheckError("Wrong function return type", node->base);
}
returned_type_ = std::nullopt;
@ -435,9 +435,7 @@ void TypeCheckVisitor::Visit(TypeConstructorPattern* node) { // TODO: match name
}
}
Visitor::Visit(type_info.node->value);
current_type_ = TypeInContext(current_type_, context);
current_type_ = context_manager_.ToModifiedValue(current_type_, utils::ValueType::Tmp);
VisitDefinedType(&type_info, context, utils::ValueType::Tmp);
node->base.type_ = current_type_;
}
@ -696,7 +694,7 @@ void TypeCheckVisitor::Visit(LoopControlExpression&) { // enum
// Operators
void TypeCheckVisitor::Visit(ReferenceExpression* node) {
Visit(node->expression.get());
Visitor::Visit(node->expression);
current_type_ = context_manager_.AddValue(
info::type::ReferenceToType({node->reference},
@ -983,6 +981,8 @@ void TypeCheckVisitor::Visit(TypeConstructor* node) {
}
}
// TODO: replace with VisitDefinedType ??
AddTypeParameterLocalTypes(&type_info);
Visitor::Visit(type_info.node->value);
std::optional<info::type::VariantType*> maybe_variant_type =
@ -1293,7 +1293,7 @@ void TypeCheckVisitor::Visit(TypeExpression* node) {
&node->base);
}
VisitDefinedType(maybe_type_info.value(), context);
VisitDefinedType(maybe_type_info.value(), context, utils::ValueType::Tmp);
} else {
error_handling::HandleTypecheckError("Type not found", node->base);
}
@ -1316,9 +1316,11 @@ void TypeCheckVisitor::Visit(TypeExpression* node) {
void TypeCheckVisitor::Visit(ExtendedScopedAnyType* node) {
Visitor::Visit(node->type);
current_type_ = context_manager_.AddValue(
info::type::ReferenceToType(node->references, current_type_, context_manager_.GetValueManager()),
utils::ValueType::Tmp);
if (!node->references.empty()) {
current_type_ = context_manager_.AddValue(
info::type::ReferenceToType(node->references, current_type_, context_manager_.GetValueManager()),
utils::ValueType::Tmp);
}
node->base.type_ = current_type_;
}
@ -1540,7 +1542,7 @@ std::optional<FunctionDeclaration*>
&node->base);
}
VisitDefinedType(maybe_type_info.value(), context);
VisitDefinedType(maybe_type_info.value(), context, utils::ValueType::Tmp);
maybe_function_declaration =
FindDefinedTypeFunctionAndUpdate(node,
maybe_type_info.value(),
@ -1580,7 +1582,7 @@ std::optional<FunctionDeclaration*> TypeCheckVisitor::FindFunctionAndUpdate(Func
&node->base);
}
VisitDefinedType(maybe_type_info.value(), {}); // TODO: context ??
VisitDefinedType(maybe_type_info.value(), {}, utils::ValueType::Tmp); // TODO: context ??
maybe_function_declaration =
FindDefinedTypeFunctionAndUpdate(node,
maybe_type_info.value(),

2
src/typed_print_visitor.cpp
View file

@ -557,7 +557,7 @@ void TypedPrintVisitor::Visit(ReferenceExpression* node) {
break;
}
out_ << "] (";
Visit(node->expression.get());
Visitor::Visit(node->expression);
out_ << ')';
}

18
src/types.cpp
View file

@ -120,13 +120,13 @@ std::optional<utils::IdType> TupleType::GetFieldType(const std::string& name,
return std::nullopt;
}
std::string TupleType::ToString() {
std::string TupleType::ToString() const {
std::string result;
result += "(";
for (auto& field : fields_) {
result += "& ";
result += " & ";
result += type_manager_->GetAnyValue(field.second)->ToString();
}
@ -185,7 +185,7 @@ std::optional<utils::IdType> VariantType::GetFieldType(const std::string& name,
return std::nullopt;
}
std::string VariantType::ToString() {
std::string VariantType::ToString() const {
std::string result;
result += "(";
@ -229,7 +229,7 @@ std::optional<utils::IdType> OptionalType::GetFieldType(const std::string&,
return std::nullopt;
}
std::string OptionalType::ToString() {
std::string OptionalType::ToString() const {
return "Optional " + type_manager_->GetAnyValue(type_)->ToString();
}
@ -263,7 +263,7 @@ std::optional<utils::IdType> ReferenceToType::GetFieldType(const std::string& na
}
std::string ReferenceToType::ToString() {
std::string ReferenceToType::ToString() const {
std::string result;
for (auto& reference : references_) {
@ -337,7 +337,7 @@ std::optional<utils::IdType> FunctionType::GetFieldType(const std::string&,
return std::nullopt;
}
std::string FunctionType::ToString() {
std::string FunctionType::ToString() const {
std::string result;
result += "(";
@ -387,7 +387,7 @@ std::optional<utils::IdType> ArrayType::GetFieldType(const std::string&,
return std::nullopt;
}
std::string ArrayType::ToString() {
std::string ArrayType::ToString() const {
return "Array (" + std::to_string(size_) + ") " + type_manager_->GetAnyValue(elements_type_)->ToString();
}
@ -554,7 +554,7 @@ std::string Type::GetTypeName() const {
return ""; // ??
}
std::string Type::ToString() {
std::string Type::ToString() const {
size_t index = type_.index();
switch (index) {
@ -562,7 +562,7 @@ std::string Type::ToString() {
return std::get<AbstractType>(type_).ToString();
case 1:
return std::get<DefinedType>(type_).ToString();
case 2:
case 2: // ??
return ::info::type::ToString(std::get<InternalType>(type_));
case 3:
return std::get<TupleType>(type_).ToString();

2
src/visitor.cpp
View file

@ -466,7 +466,7 @@ void Visitor::Visit(LoopControlExpression&) {} // enum
// Operators
void Visitor::Visit(ReferenceExpression* node) {
Visit(node->expression.get());
Visit(node->expression);
}
void Visitor::Visit(AccessExpression* node) {

18
tests/arrays.lang
View file

@ -9,13 +9,13 @@ def test_arrays = {
var arr6 <- String._new_array: 10
var arr6_reference = ^arr6
const elem1 = arr1`0
var elem2 = arr1`2
const ref1 = ^arr1`1
var ref2 = ^arr1`3
; arr1`1 = 123
; ~ref1 = arr1`2 // set value
; ref1 = ref2 // set pointer / reference
//
// const elem1 = arr1`0
// var elem2 = arr1`2
// const ref1 = ^arr1`1
// var ref2 = ^arr1`3
// ; arr1`1 = 123
//
// ; ~ref1 = arr1`2 // set value
// ; ref1 = ref2 // set pointer / reference
}

188
tests/stdlib.lang
View file

@ -0,0 +1,188 @@
basic (Float : #Ord #Div #Str)
basic (Int : #Ord #IDiv #Str)
basic (String : #Ord #Str #CharContainer #Copy)
basic (Char : #Ord #Str #Copy)
basic (Bool : #Ord #Str #Copy)
basic (Unit : #Str #Copy)
//
decl not : Bool -> Bool
def not : x =
(match x with
| true -> false
| false -> true)
decl ( && ) : Bool -> Bool -> Bool
def ( && ) : x y =
match x with
| true -> (
match y with
| true -> true
| false -> false
)
| false -> false
decl ( || ) : Bool -> Bool -> Bool
def ( || ) : x y =
match x with
| true -> true
| false -> (
match y with
| true -> true
| false -> false
)
//
typeclass CharContainer =
& var size : -> Int
& var at : Int -> Char
//
typeclass Move = // TODO
& var ( <- ) : Move -> Unit
typeclass Copy =
& var ( = ) : Copy -> Unit
//
typeclass (Sum : #Copy) =
& var ( += ) : Sum -> Unit
& var ( -= ) : Sum -> Unit
& var ( + ) : Sum -> Sum
& var ( - ) : Sum -> Sum
& zero : -> Sum
namespace var Sum {
def ( + ) : x = {
var ans = self
; ans += x
return ans
}
def ( - ) : x = {
var ans = self
; ans -= x
return ans
}
}
typeclass (Mult : #Sum) =
& var ( *= ) : Mult -> Unit
& var ( * ) : Mult -> Mult
namespace var Mult {
def ( * ) : x = {
var ans = self
; ans *= x
return ans
}
}
typeclass (IDiv : #Mult) =
& var div : IDiv -> IDiv
& var mod : IDiv -> IDiv
namespace var IDiv {
def mod : x = self -. x * self.div: x
}
typeclass (Div : #Mult) =
& var ( /= ) : Div -> Unit
& var ( / ) : Div -> Div
namespace var Div {
def ( / ) : x = {
var ans = self
; ans /= x
return ans
}
}
//
typeclass Eq =
& var ( == ) : Eq -> Bool
& var ( != ) : Eq -> Bool
namespace var Eq {
def ( != ) : x = not: (self == x)
}
//
struct Order =
| EQ
| LT
| GT
typeclass (Ord : #Eq) =
& var compare : Ord -> Order
& var ( < ) : Ord -> Bool
& var ( >= ) : Ord -> Bool
& var ( > ) : Ord -> Bool
& var ( <= ) : Ord -> Bool
decl min ('A : #Ord) : 'A -> 'A -> 'A
def min : x y = if x < y then x else y
decl max ('A : #Ord) : 'A -> 'A -> 'A
def max : x y = if x < y then y else x
namespace var Ord {
def compare : x =
if self == x then $EQ
elif self < x then $LT
else $GT
def ( >= ) : x = not: (self < x)
def ( > ) : x = x < self
def ( <= ) : x = not: (x < self)
}
//
typeclass Show =
& var show : -> String
typeclass Read =
& read : String -> Read
typeclass (Str : #Show #Read)
// typeclass DebugShow = // TODO
// & debug_show : -> String
//
typeclass Default =
& default : -> Default
//
typeclass Bounded =
& min_bound : -> Bounded
& max_bound : -> Bounded
& var is_max_bound : -> Bool
& var is_min_bound : -> Bool
//
typeclass Enum =
& var succ : -> (Optional Enum)
& var pred : -> (Optional Enum)
& to_enum : Int -> Enum
& var from_enum : -> Int
//
namespace IO {
decl print : String -> Unit
decl scan : -> String
decl random : -> Int // TODO
}
//

52
tests/test_code.lang
View file

@ -41,8 +41,8 @@ typeclass CharContainer =
//
typeclass Move =
& var ( <- ) : Move -> Unit // TODO
typeclass Move = // TODO
& var ( <- ) : Move -> Unit
typeclass Copy =
& var ( = ) : Copy -> Unit
@ -201,9 +201,6 @@ namespace IO {
//
decl ret_one : -> Int
def ret_one = 1
decl ( -- ) : Int -> Int -> Int_0
def ( -- ) : begin end = {
var current = begin
@ -242,17 +239,48 @@ def scan_anything = 'A.read: (IO.scan:)
decl print_anything ('A : #Show) : 'A -> Unit
def print_anything : x = IO.print: (x.show:)
// decl sorted ('A : #Ord #Copy): 'A_0 -> Int -> 'A_0
// def sorted : a sz = {
// var a_copy = a
// if sz == 2 then {
// if a_copy`0 > a_copy`1 then {
// var x = a_copy`0
// a_copy`0 = a_copy`1
// a_copy`1 = x
// }
// return a_copy
// }
//
// var center = sz.div: 2
//
// var a_left = for i in 0--center do a`i
// var a_right = for i in center-sz do a`i
//
// return a_copy
// }
/*
struct Array 'A = & data : 'A_0
namespace Array {
decl construct : 'A_0 -> Array
def construct: x = $(Array 'A) & data = x
} // TODO: construct decl + default def -> segfault
*/
decl of : 'A_0 -> Array
def of: x = $(Array 'A) & data = x
}*/
struct ThreeTuple = & String & String & String
decl scan_three_t : -> ThreeTuple
def scan_three_t = $ThreeTuple & IO.scan: & IO.scan: & IO.scan:
decl scan_three : -> (& String & String & String)
def scan_three = & IO.scan: & IO.scan: & IO.scan:
// var n = scan_anything Int:
// var a = $(Array Int) & data = (for _ in 0--n do scan_int:)
// ; print_anything Int: n
exec main {
var n = scan_anything Int:
var a = for _ in 0--n do scan_int:
; print_anything Int: n
var & a & b & c = scan_three_t:
; IO.print: b
var & d & e & f = scan_three:
; IO.print: e
}