Feature: Type deduction struct field ptr inst

include/GIL/Instructions/Aggregates/StructFieldPtrInst.hpp

@@ -1,6 +1,7 @@
 #ifndef GLU_GIL_INSTRUCTIONS_STRUCT_FIELD_PTR_INST_HPP
 #define GLU_GIL_INSTRUCTIONS_STRUCT_FIELD_PTR_INST_HPP
 
+#include "AST/Types/PointerTy.hpp"
 #include "AggregateInst.hpp"
 
 namespace glu::gil {
@@ -32,6 +33,8 @@ class StructFieldPtrInst : public AggregateInst {
         , _member(member)
         , _ptr(pointerType)
     {
+        auto *ptrType = llvm::cast<types::PointerTy>(pointerType);
+        assert(ptrType->getPointee() == member.getType());
     }
 
     /// @brief Gets the result type at the specified index.

include/GILGen/Context.hpp

@@ -411,11 +411,10 @@ class Context {
     gil::StructFieldPtrInst *
     buildStructFieldPtr(gil::Value structPtr, gil::Member member)
     {
-        // Create a pointer type to the field type
-        auto *fieldPtrType = _functionDecl->getModule()
-                                 ->getContext()
+        auto *fieldPtrType = getASTContext()
                                  ->getTypesMemoryArena()
-                                 .create<glu::types::PointerTy>(member.getType()
+                                 .create<glu::types::PointerTy>(
+                                     member.getType()
                                  );
         return insertInstruction(
             new gil::StructFieldPtrInst(structPtr, member, fieldPtrType)

test/GILGen/GILGenStmt.cpp

@@ -1,4 +1,5 @@
 #include "GILGen/GILGen.hpp"
+#include "Instructions.hpp"
 #include "Parser.hpp"
 #include "Scanner.hpp"
 #include "Sema/Sema.hpp"
@@ -43,3 +44,42 @@ TEST(GILGenStmt, Empty)
         bb->getInstructions().front().getKind(), InstKind::ReturnInstKind
     );
 }
+
+TEST(GILGenStmt, StructFieldPtrResultTypePointsToFieldType)
+{
+    PREP_PARSER(R"(
+        struct Inner {
+            value: Int
+        }
+
+        func copy(i: *Inner) -> Inner {
+            var result: Inner;
+            result.value = i.*.value;
+            return result;
+        }
+    )");
+
+    ASSERT_EQ(module->getDecls().size(), 2u);
+    auto *fn = llvm::cast<FunctionDecl>(module->getDecls()[1]);
+    auto gilModule = std::make_unique<gil::Module>("test_module");
+    GlobalContext globalCtx(gilModule.get());
+    auto *f = generateFunction(gilModule.get(), fn, globalCtx);
+
+    auto *structFieldPtrInst = [&]() -> StructFieldPtrInst * {
+        for (auto &bb : f->getBasicBlocks()) {
+            for (auto &inst : bb.getInstructions()) {
+                if (auto *fieldPtr = llvm::dyn_cast<StructFieldPtrInst>(&inst))
+                    return fieldPtr;
+            }
+        }
+        return nullptr;
+    }();
+
+    ASSERT_NE(structFieldPtrInst, nullptr);
+    auto *resultType
+        = llvm::dyn_cast<types::PointerTy>(structFieldPtrInst->getResultType());
+    ASSERT_NE(resultType, nullptr);
+    EXPECT_EQ(
+        resultType->getPointee(), structFieldPtrInst->getMember().getType()
+    );
+}