optionals using '?' and optional coelescing like '?.', '?[...]', etc

Author: ephf

lib/string.qk

@@ -7,6 +7,10 @@ struct str {
 	usize len(self) {
 		return self.slice.size;
 	}
+
+	char* data(self) {
+		return self.slice.data;
+	}
 }
 
 struct String {

src/compiler/left.c

@@ -65,7 +65,8 @@ void comp_Identifier(Identifier* self, str* line, Compiler* compiler) {
 	if(self->declaration && self->declaration->generics.base.size
 			&& self->declaration->generics.stack.size
 			&& !(self->flags & fExternal)) {
-		append_generics_identifier(line, last(self->declaration->generics.stack));
+		append_generics_identifier(line, last(self->declaration->generics.stack),
+				StringifyAlphaNum);
 	}
 }
 
@@ -93,6 +94,8 @@ void comp_Scope(Scope* self, str* line, Compiler* compiler) {
 		str bracket = new_line(compiler);
 		push(&compiler->sections.data[compiler->open_section].lines, strf(&bracket, "}"));
 	}
+
+	if(self->value) self->value->compiler(self->value, line, compiler);
 }
 
 void comp_Missing(Missing* self, str* line, Compiler* compiler) {

src/compiler/right.c

@@ -144,7 +144,8 @@ void comp_FunctionType(FunctionType* self, str* line, Compiler* compiler) {
 
 	strf(line, "__Function%zd", self->typedef_id);
 	if(self->declaration->generics.stack.size) {
-		append_generics_identifier(line, last(self->declaration->generics.stack));
+		append_generics_identifier(line, last(self->declaration->generics.stack),
+				StringifyAlphaNum);
 	}
 }
 

src/parser/generics.c

@@ -144,12 +144,25 @@ void apply_generics(Declaration* declaration, GenericsCollection collection) {
 	init_scope(&declaration->generics.unique_map);
 }
 
-void append_generics_identifier(str* string, TypeList generics) {
+void append_generics_identifier(str* string, TypeList generics, unsigned flags) {
 	if(!generics.size) return;
 
+	if(!(flags & 1 << 0 /* StringifyAlphaNum */)) {
+		strf(string, "<");
+	}
+
 	for(size_t i = 0; i < generics.size; i++) {
-		strf(string, "__");
-		stringify_type(generics.data[i], string, 1 << 0 /* StringifyAlphaNum */);
+		if(flags & 1 << 0 /* StringifyAlphaNum */) {
+			strf(string, "__");
+		} else if(i) {
+			strf(string, ", ");
+		}
+
+		stringify_type(generics.data[i], string, flags);
+	}
+
+	if(!(flags & 1 << 0 /* StringifyAlphaNum */)) {
+		strf(string, ">");
 	}
 }
 
@@ -160,7 +173,8 @@ strs filter_unique_generics_variants(TypeLists variants, str base) {
 
 	for(size_t i = 0; i < variants.size; i++) {
 		str identifier = strf(0, "%.*s", (int) base.size, base.data);
-		append_generics_identifier(&identifier, variants.data[i]);
+		append_generics_identifier(&identifier, variants.data[i], 
+				1 << 0 /* StringifyAlphaNum */);
 
 		if(get(variants_set, (Trace) { .slice = identifier })) {
 			variants.data[i].size = 0;

src/parser/nodes.c

@@ -33,6 +33,7 @@ typedef struct {
 	DeclarationList declarations;
 	NodeList children;
 	Declaration* parent;
+	Node* value;
 	unsigned wrap_brackets : 1;
 } Scope;
 typedef Vector(Scope*) Stack;

src/parser/right.c

@@ -15,6 +15,7 @@ enum {
 	RightFieldAccess,
 	RightCompare,
 	RightIndex,
+	RightOptional,
 };
 
 typedef struct {
@@ -28,6 +29,7 @@ RightOperator right_operator_table[128] = {
 	[TokenDoublePlus] = { 1, RightIncDec }, [TokenDoubleMinus] = { 1, RightIncDec },
 	['['] = { 1, RightIndex }, ['('] = { 1, RightCall },
 	['.'] = { 1, RightFieldAccess }, [TokenRightArrow] = { 1, RightFieldAccess },
+	['?'] = { 1, RightOptional },
 
 	['*'] = { 3, RightAltBinary }, ['/'] = { 3 }, ['%'] = { 3 },
 
@@ -171,6 +173,18 @@ Message see_declaration(Declaration* declaration, Node* node) {
 					(int) node->trace.slice.size, node->trace.slice.data));
 }
 
+Node* temp_value(Node* value, Parser* parser, unsigned* set_id) {
+	static unsigned id = 0;
+	if(set_id) *set_id = id;
+	const str declaration_code = strf(0, "auto __qv%u = extern<auto> \"\";%c", id++, '\0');
+	Node* declaration = eval_w(parser->tokenizer->current.trace.filename,
+			declaration_code.data, parser, &statement);
+	declaration->Statement.expression->BinaryOperation.right = value;
+	clash_types(declaration->Statement.expression->BinaryOperation.left->type,
+			value->type, value->trace, parser->tokenizer->messages, 0);
+	return declaration;
+}
+
 Node* right(Node* lefthand, Parser* parser, unsigned char precedence) {
 	RightOperator operator;
 outer_while:
@@ -179,6 +193,78 @@ Node* right(Node* lefthand, Parser* parser, unsigned char precedence) {
 		if(operator.precedence == 6 && collecting_type_arguments) break;
 
 		switch(operator.type) {
+			case RightOptional: {
+				Trace trace_end = next(parser->tokenizer).trace;
+
+				if((operator = right_operator_table[parser->tokenizer->current.type])
+						.precedence <= 1) {
+					unsigned temp_id;
+					Node* temp = temp_value(lefthand, parser, &temp_id);
+
+					const str left_value_code = strf(0, "__qv%u.value%c", temp_id, '\0');
+					Node* some_branch = right(eval(NULL, left_value_code.data, parser),
+							parser, 2);
+
+					Scope* collection = new_scope(NULL);
+					collection->trace = lefthand->trace;
+					collection->wrap_brackets = 1;
+					push(&collection->children, temp);
+
+					const OpenedType open = open_type(some_branch->type, 0);
+					if(open.type->compiler == (void*) comp_External &&
+							streq(open.type->External.data, str("void"))) {
+						Node* if_statement = eval_w(NULL, strf(0,
+									"if(__qv%u.some) extern<auto> _;%c", temp_id, '\0').data,
+								parser, &statement);
+						if_statement->Control.body->children.data[0]->Statement.expression
+							= some_branch;
+						push(&collection->children, if_statement);
+						close_type(open.actions, 0);
+						return (void*) collection;
+					}
+					close_type(open.actions, 0);
+
+					unsigned value_id;
+					Node* value = temp_value(eval(NULL, "Option::None()", parser),
+							parser, &value_id);
+					
+					const str if_statement_code = strf(0,
+							"if(__qv%u.some) __qv%u = Option::Some(extern<auto> _);%c",
+							temp_id, value_id, '\0');
+					Node* if_statement = eval_w(NULL, if_statement_code.data, parser,
+							&statement);
+					printf("%p %p\n", 
+							if_statement->Control.body->children.data[0]->compiler,
+							comp_Statement);
+					// exit(1);
+					clash_types(if_statement->Control.body->children.data[0]->Statement
+							.expression->BinaryOperation.right->FunctionCall.arguments
+							.data[0]->type, some_branch->type, some_branch->trace,
+							parser->tokenizer->messages, 0);
+					if_statement->Control.body->children.data[0]->Statement.expression
+						->BinaryOperation.right->FunctionCall.arguments.data[0] = some_branch;
+					
+					push(&collection->children, value);
+					push(&collection->children, if_statement);
+					collection->value = eval(NULL, strf(0, "__qv%u%c", value_id, 0).data,
+							parser);
+					collection->type = collection->value->type;
+
+					lefthand = (void*) collection;
+					break;
+				}
+
+				if(lefthand->flags & fType) {
+					Wrapper* option = (void*) eval("option", "Option", parser);
+					clash_types(option->action.TypeList.data[0], (void*) lefthand, 
+							stretch(lefthand->trace, trace_end),
+							parser->tokenizer->messages, 0);
+					lefthand = (void*) option;
+					break;
+				}
+				break;
+			}
+
 			case RightIncDec: {
 				if(!(lefthand->flags & fMutable) || lefthand->type->flags & fConst) {
 					push(parser->tokenizer->messages, Err( lefthand->trace,
@@ -187,13 +273,14 @@ Node* right(Node* lefthand, Parser* parser, unsigned char precedence) {
 
 				Trace operator = next(parser->tokenizer).trace;
 
-				return new_node((Node) { .Postfix = {
+				lefthand = new_node((Node) { .Postfix = {
 						.compiler = (void*) &comp_Postfix,
 						.trace = operator,
 						.type = lefthand->type,
 						.child = lefthand,
 						.postfix = operator.slice,
 				}});
+				break;
 			}
 
 			case RightAltBinary: {
@@ -330,7 +417,7 @@ Node* right(Node* lefthand, Parser* parser, unsigned char precedence) {
 				}});
 			}
 
-			case RightFieldAccess: {
+			case RightFieldAccess: field_access: {
 				Type* type = lefthand->type;
 				if(parser->tokenizer->current.type == TokenRightArrow) {
 					type = (void*) dereference((void*) type, lefthand->trace,

src/parser/types.c

@@ -39,7 +39,8 @@ int type_state_action(TypeStateAction action, unsigned flags) {
 			if(in_compiler_step && noloop && !(flags & ActionNoChildCompilation)) {
 				noloop = 0;
 				str unique_key = { 0 };
-				append_generics_identifier(&unique_key, action.TypeList);
+				append_generics_identifier(&unique_key, action.TypeList, 
+						1 << 0 /* StringifyAlphaNum */);
 				noloop = 1;
 
 				if(!get(action.target->Declaration.generics.unique_map,
@@ -286,6 +287,10 @@ int stringify_acceptor(Type* type, Type* _, StringifyAccumulator* accumulator) {
 				? "struct_%.*s" : "struct %.*s",
 				(int) type->StructType.parent->identifier->base.size,
 				type->StructType.parent->identifier->base.data);
+		if(type->StructType.parent->generics.stack.size) {
+			append_generics_identifier(accumulator->string,
+					last(type->StructType.parent->generics.stack), accumulator->flags);
+		}
 		return 1;
 	} else {
 		strf(accumulator->string, accumulator->flags & StringifyAlphaNum

src/trace.c

@@ -40,17 +40,14 @@ int streq(str a, str b) {
 
 Trace stretch(Trace a, Trace b) {
 	a.slice.size = b.slice.data - a.slice.data + b.slice.size;
+	if(a.slice.size >= 256) a.slice.size = 16;
 	return a;
 }
 
-#define Err(trace, content) \
-	((Message) { trace, "\33[31m", "error", content })
-#define Hint(content) \
-	((Message) { { 0 }, "\33[36m", "hint", content })
-#define See(trace, content) \
-	((Message) { trace, "\33[36m", "see", content })
-#define Warn(trace, content) \
-	((Message) { trace, "\33[33m", "warning", content })
+#define Err(trace, content) ((Message) { trace, "\33[31m", "error", content })
+#define Hint(content) ((Message) { { 0 }, "\33[36m", "hint", content })
+#define See(trace, content) ((Message) { trace, "\33[36m", "see", content })
+#define Warn(trace, content) ((Message) { trace, "\33[33m", "warning", content })
 
 int print_message(Message message) {
 	if(!message.trace.filename) {

test/main

@@ -8,11 +8,14 @@ struct Slice__char { char* data; size_t size; };
 struct str { struct Slice__char slice; };
 struct Vec__char { char* data; size_t size; size_t capacity; };
 struct String { struct Vec__char vector; };
+struct Option__ptrto_uint32_t { uint32_t* value; bool some; };
+struct Option__uint32_t { uint32_t value; bool some; };
 
 int main();
 struct Range Range__new(size_t, size_t);
 size_t Range__len(struct Range);
 size_t str__len(struct str);
+char* str__data(struct str);
 struct String str__to_owned(struct str);
 struct Vec__char Vec__char__new();
 size_t Vec__char__len(struct Vec__char);
@@ -25,10 +28,29 @@ struct String String__new();
 struct String String__from(struct str);
 struct str String__to_str(struct String);
 void print(struct str);
+struct Option__ptrto_uint32_t Option__ptrto_uint32_t__Some(uint32_t*);
+struct Option__ptrto_uint32_t Option__ptrto_uint32_t__None();
+bool Option__ptrto_uint32_t__is_some(struct Option__ptrto_uint32_t);
+bool Option__ptrto_uint32_t__is_none(struct Option__ptrto_uint32_t);
+struct Option__uint32_t Option__uint32_t__Some(uint32_t);
+struct Option__uint32_t Option__uint32_t__None();
+bool Option__uint32_t__is_some(struct Option__uint32_t);
+bool Option__uint32_t__is_none(struct Option__uint32_t);
 
 
 int main() {
-    print((struct str) { "Hello World", (sizeof("Hello World") - 1) });
+    struct Option__ptrto_uint32_t x;
+    struct Option__uint32_t y;
+    struct Option__ptrto_uint32_t __qv0;
+    struct Option__uint32_t __qv1;
+    (x = Option__ptrto_uint32_t__None());
+    {
+        (__qv0 = x);
+        (__qv1 = Option__uint32_t__None());
+        if((__qv0 . some)) 
+            (__qv1 = Option__uint32_t__Some((*((__qv0 . value) + 0))));
+    }
+    (y = __qv1);
 }
 
 
@@ -47,6 +69,11 @@ size_t str__len(struct str self) {
 }
 
 
+char* str__data(struct str self) {
+    return ((self . slice) . data);
+}
+
+
 struct String str__to_owned(struct str self) {
     struct String string;
     (string = String__new());
@@ -132,3 +159,43 @@ void print(struct str message) {
     fwrite(((message . slice) . data), ((message . slice) . size), sizeof(char), stdout);
     fwrite((&newline), 1, sizeof(char), stdout);
 }
+
+
+struct Option__ptrto_uint32_t Option__ptrto_uint32_t__Some(uint32_t* value) {
+    return (struct Option__ptrto_uint32_t) { value, (bool) 1 };
+}
+
+
+struct Option__ptrto_uint32_t Option__ptrto_uint32_t__None() {
+    return (struct Option__ptrto_uint32_t) { .some = (bool) 0 };
+}
+
+
+bool Option__ptrto_uint32_t__is_some(struct Option__ptrto_uint32_t self) {
+    return (self . some);
+}
+
+
+bool Option__ptrto_uint32_t__is_none(struct Option__ptrto_uint32_t self) {
+    return (1 - (self . some));
+}
+
+
+struct Option__uint32_t Option__uint32_t__Some(uint32_t value) {
+    return (struct Option__uint32_t) { value, (bool) 1 };
+}
+
+
+struct Option__uint32_t Option__uint32_t__None() {
+    return (struct Option__uint32_t) { .some = (bool) 0 };
+}
+
+
+bool Option__uint32_t__is_some(struct Option__uint32_t self) {
+    return (self . some);
+}
+
+
+bool Option__uint32_t__is_none(struct Option__uint32_t self) {
+    return (1 - (self . some));
+}