Added support for nested structs.

source/compiler/compiler/compiler.cpp

@@ -34,14 +34,14 @@ namespace sigma {
 		TRY(tokenizer::tokenize(file, &m_description.source_path, frontend));
 		TRY(parser::parse(frontend));
 
-		frontend.syntax.print_ast();
-
 		// backend
 		// at this point we want to merge all frontend contexts into the backend context
 		backend_context backend(frontend.syntax, m_description.target);
 
 		// run analysis on the generated AST
 		TRY(type_checker::type_check(backend));
+		backend.syntax.print_ast();
+
 		TRY(ir_translator::translate(backend));
 
 		// compile the generated IR module

source/compiler/compiler/type_system/data_type.cpp

@@ -19,7 +19,7 @@ namespace sigma {
 			case token_type::IDENTIFIER: {
 				// custom types, resolved in the type checker
 				base_type = UNRESOLVED;
-				identifier_key = token.symbol_key;
+				unresolved_key = token.symbol_key;
 				break;
 			}
 			default: PANIC("undefined token -> type conversion for token '{}'", token.tok.to_string());

source/compiler/compiler/type_system/data_type.h

@@ -68,6 +68,7 @@ namespace sigma {
 		auto get_alignment() const -> u16;
 		auto get_size() const -> u16;
 
+		utility::string_table_key unresolved_key;
 		utility::string_table_key identifier_key;
 		utility::slice<data_type> members;
 

source/compiler/compiler/type_system/semantic_context.cpp

@@ -231,12 +231,14 @@ namespace sigma {
 			return SUCCESS; // nothing else needed
 		}
 
-		if(const handle<data_type> resolved = m_current_scope->find_type(type.identifier_key)) {
-			type = *resolved;
+		if(const handle<data_type> resolved = m_current_scope->find_type(type.unresolved_key)) {
+			type.members = resolved->members;
+			type.base_type = resolved->base_type;
+			type.pointer_level = resolved->pointer_level;
 			return SUCCESS;
 		}
 
-		const std::string& identifier = m_context.syntax.strings.get(type.identifier_key);
+		const std::string& identifier = m_context.syntax.strings.get(type.unresolved_key);
 		return error::emit(error::code::UNKNOWN_TYPE, location, identifier);
 	}
 

source/compiler/test/main.s

@@ -14,17 +14,20 @@
 //     -    add more test cases
 
 i32 main() {
-	i32*** memory = cast<i32***>(malloc(100));
+	struct key {
+		i32* value;
+	};
 
-	memory[0] = cast<i32**>(malloc(100));
-	memory[1] = cast<i32**>(malloc(100));
+	struct user {
+		key k;
+	};
 
-	memory[0][0] = cast<i32*>(malloc(100));
-	memory[1][0] = cast<i32*>(malloc(100));
+	user my_user;
 
-	memory[0][0][0] = 1;
-	memory[1][0][0] = 2;
+	my_user.k.value = cast<i32*>(malloc(sizeof(i32) * 2));
+	my_user.k.value[0] = 123;
+	my_user.k.value[1] = 321;
 
-	printf("%d %d\n", memory[0][0][0], memory[1][0][0]);
+	printf("key: %d %d\n", my_user.k.value[0], my_user.k.value[1]);
 	ret 0;
 }

source/type_checker/type_checker.cpp

@@ -412,10 +412,10 @@ namespace sigma {
 	}
 
 	auto type_checker::type_check_struct_declaration(ast_node declaration) const -> type_check_result {
-		const auto& expression = declaration->get<ast::named_type_expression>();
+		auto& expression = declaration->get<ast::named_type_expression>();
 
 		// verify that no two members of the struct have the same identifier
-		const auto& members = expression.type.members;
+		auto& members = expression.type.members;
 
 		for (u64 i = 0; i < members.get_size(); ++i) {
 			for (u64 j = i + 1; j < members.get_size(); ++j) {
@@ -426,6 +426,11 @@ namespace sigma {
 			}
 		}
 
+		// resolve inner types
+		for(auto& member : members) {
+			TRY(m_context.semantics.resolve_type(member, declaration->location));
+		}
+
 		TRY(m_context.semantics.declare_struct(declaration));
 		return data_type::create_unknown(); // not used
 	}

tests/structs/multiple_access.s

@@ -0,0 +1,16 @@
+i32 main() {
+	struct key {
+		i32 value;
+	};
+
+	struct user {
+		key k;
+	};
+
+	user my_user;
+
+	my_user.k.value = 100;
+
+	printf("key: %d\n", my_user.k.value);
+	ret 0;
+}

tests/structs/multiple_access_expected.txt

@@ -0,0 +1 @@
+key: 100

tests/structs/multiple_access_ptr.s

@@ -0,0 +1,18 @@
+i32 main() {
+	struct key {
+		i32* value;
+	};
+
+	struct user {
+		key k;
+	};
+
+	user my_user;
+
+	my_user.k.value = cast<i32*>(malloc(sizeof(i32) * 2));
+	my_user.k.value[0] = 123;
+	my_user.k.value[1] = 321;
+
+	printf("key: %d %d\n", my_user.k.value[0], my_user.k.value[1]);
+	ret 0;
+}

tests/structs/multiple_access_ptr_expected.txt

@@ -0,0 +1 @@
+key: 123 321