style: Apply clang-format to copy function implementation

Fix code formatting for copy function overload feature:
- Fix line wrapping in CopyLoweringPass comments and long lines
- Fix whitespace in StoreInst.hpp
- Align header includes alphabetically
- Fix string concatenation formatting in ValidCopyOverloadChecker
- Remove trailing whitespace

Author: badermarouan

include/GIL/Instructions/StoreInst.hpp

@@ -42,6 +42,8 @@ class StoreInst : public InstBase {
     Value getSource() const { return _source; }
     Value getDest() const { return _dest; }
 
+    void setSource(Value source) { _source = source; }
+
     StoreOwnershipKind getOwnershipKind() const { return _ownershipKind; }
     void setOwnershipKind(StoreOwnershipKind kind) { _ownershipKind = kind; }
 

include/GILGen/Context.hpp

@@ -467,6 +467,32 @@ class Context {
         auto *loadInst = buildLoad(valueType, ptr, gil::LoadOwnershipKind::Take);
         return buildDrop(loadInst->getResult(0));
     }
+
+    gil::CopyInst *buildCopy(gil::Value value)
+    {
+        if (value.getType()->isTrivial()) {
+            // No need to copy trivial types
+            return nullptr;
+        }
+        if (auto *structure
+            = llvm::dyn_cast<types::StructTy>(value.getType().getType())) {
+            if (structure->getDecl()->hasOverloadedCopyFunction()) {
+                // Make sure the copy function is created
+                getOrCreateGILFunction(structure->getDecl()->getCopyFunction());
+            }
+        }
+        return insertInstruction(new (_arena) gil::CopyInst(value));
+    }
+
+    gil::CopyInst *buildCopyPtr(gil::Type valueType, gil::Value ptr)
+    {
+        if (valueType->isTrivial()) {
+            // No need to copy trivial types
+            return nullptr;
+        }
+        auto *loadInst = buildLoad(valueType, ptr, gil::LoadOwnershipKind::Take);
+        return buildCopy(loadInst->getResult(0));
+    }
 };
 
 } // namespace glu::gilgen

include/Optimizer/GILPasses.def

@@ -9,5 +9,6 @@ GIL_PASS("void-main", VoidMainPass)
 GIL_PASS("dce", DeadCodeEliminationPass)
 GIL_PASS("unreachable-checker", UnreachableInstChecker)
 GIL_PASS("drop-lowering", DropLoweringPass)
+GIL_PASS("copy-lowering", CopyLoweringPass)
 
 #undef GIL_PASS

lib/ASTPrinter/ASTPrinter.cpp

@@ -67,8 +67,6 @@ class ASTPrinter : public ASTVisitor<ASTPrinter> {
         llvm::WithColor(out, llvm::raw_ostream::MAGENTA) << node->getKind();
         out << " " << node;
 
-        auto &sm = *_srcManager;
-
         printSourceLocation(node);
 
         if (auto *expr = llvm::dyn_cast<ExprBase>(node)) {
@@ -170,6 +168,12 @@ class ASTPrinter : public ASTVisitor<ASTPrinter> {
             printSourceLocation(node->getDropFunction());
             out << '\n';
         }
+        if (node->hasOverloadedCopyFunction()) {
+            out.indent(_indent - 2);
+            out << "-->Copy function: " << node->getCopyFunction();
+            printSourceLocation(node->getCopyFunction());
+            out << '\n';
+        }
     }
 
     /// @brief Visits a TypeAliasDecl node.

lib/GILGen/GILGenExpr.cpp

@@ -159,7 +159,6 @@ struct GILGenExpr : public ASTVisitor<GILGenExpr, gil::Value> {
         // Handle Char to Int
         if (llvm::isa<types::CharTy>(sourceType)
             && llvm::isa<types::IntTy>(destType)) {
-            types::CharTy *charTy = llvm::cast<types::CharTy>(sourceType);
             types::IntTy *intTy = llvm::cast<types::IntTy>(destType);
 
             // Char to Int conversion - extend based on signedness
@@ -391,7 +390,7 @@ struct GILGenExpr : public ASTVisitor<GILGenExpr, gil::Value> {
     {
         // Look up the variable in the current scope
         auto varDecl = expr->getVariable();
-        if (auto fn = llvm::dyn_cast<FunctionDecl *>(varDecl)) {
+        if (/*auto fn = */ llvm::dyn_cast<FunctionDecl *>(varDecl)) {
             // FIXME: probably wrong between function  typeand function pointer
             // TODO: need gil::Function from ast::FunctionDecl
             // return ctx.buildFunctionPtr(

lib/GILGen/GILGenStmt.cpp

@@ -209,7 +209,7 @@ struct GILGenStmt : public ASTVisitor<GILGenStmt, void> {
         ctx.buildDrop(value);
     }
 
-    void visitForStmt(ForStmt *stmt)
+    void visitForStmt([[maybe_unused]] ForStmt *stmt)
     {
         // TODO: We need sema to can implement this
 

lib/Optimizer/CMakeLists.txt

@@ -23,4 +23,5 @@ target_sources(Optimizer
     GILPasses/DeadCodeEliminationPass.cpp
     GILPasses/UnreachableInstChecker.cpp
     GILPasses/DropLoweringPass.cpp
+    GILPasses/CopyLoweringPass.cpp
 )

lib/Optimizer/GILPasses/CopyLoweringPass.cpp

@@ -0,0 +1,131 @@
+#include "GIL/InstVisitor.hpp"
+#include "GIL/Module.hpp"
+#include "GILGen/Context.hpp"
+#include "Instructions/LoadInst.hpp"
+#include "Instructions/ReturnInst.hpp"
+#include "PassManager.hpp"
+
+namespace glu::optimizer {
+
+class CopyLoweringPass : public gil::InstVisitor<CopyLoweringPass> {
+private:
+    gil::Module *module;
+    std::optional<gilgen::Context> ctx = std::nullopt;
+    llvm::BumpPtrAllocator &arena;
+    llvm::SmallVector<gil::InstBase *, 8> toErase;
+    bool inCopyFunction = false; // Track if we're inside a copy function
+
+public:
+    CopyLoweringPass(gil::Module *module, llvm::BumpPtrAllocator &arena)
+        : module(module), arena(arena)
+    {
+    }
+
+    ~CopyLoweringPass()
+    {
+        for (auto *inst : toErase) {
+            inst->eraseFromParent();
+        }
+    }
+
+    void visitLoadInst(gil::LoadInst *loadInst)
+    {
+        // Don't transform loads inside copy functions (would cause infinite
+        // recursion)
+        if (inCopyFunction)
+            return;
+
+        // Only handle load [copy] instructions
+        if (loadInst->getOwnershipKind() != gil::LoadOwnershipKind::Copy)
+            return;
+
+        if (!ctx)
+            return;
+
+        // Generate code to call the copy function if it exists
+        auto *structure = llvm::dyn_cast<types::StructTy>(
+            loadInst->getResultType(0).getType()
+        );
+        if (structure && structure->getDecl()->hasOverloadedCopyFunction()) {
+            // Change the load to trivial ownership (no copy semantics)
+            loadInst->setOwnershipKind(gil::LoadOwnershipKind::Trivial);
+
+            // Insert a call to the copy function after the load
+            auto *bb = loadInst->getParent();
+            auto it = std::next(loadInst->getIterator());
+            gil::InstBase *nextInst
+                = (it != bb->getInstructions().end()) ? &*it : nullptr;
+
+            ctx->setInsertionPoint(bb, nextInst);
+            ctx->setSourceLoc(loadInst->getLocation());
+
+            // Call the copy function with the loaded value
+            auto *callInst = ctx->buildCall(
+                structure->getDecl()->getCopyFunction(),
+                { loadInst->getResult(0) }
+            );
+
+            // Find the store that uses this load's result and update it
+            if (nextInst && llvm::isa<gil::StoreInst>(nextInst)) {
+                auto *storeInst = llvm::cast<gil::StoreInst>(nextInst);
+                if (storeInst->getSource() == loadInst->getResult(0)) {
+                    // Replace the store's source with the call result
+                    storeInst->setSource(callInst->getResult(0));
+                }
+            }
+        }
+    }
+
+    void visitCopyInst(gil::CopyInst *copyInst)
+    {
+        if (!ctx)
+            return;
+
+        auto *bb = copyInst->getParent();
+        ctx->setInsertionPoint(bb, copyInst);
+        ctx->setSourceLoc(copyInst->getLocation());
+
+        // Generate code to call the copy function if it exists
+        if (auto *structure = llvm::dyn_cast<types::StructTy>(
+                copyInst->getSource().getType().getType()
+            )) {
+            if (structure->getDecl()->hasOverloadedCopyFunction()) {
+                auto *callInst = ctx->buildCall(
+                    structure->getDecl()->getCopyFunction(),
+                    { copyInst->getSource() }
+                );
+                // Replace the copy instruction with the call instruction
+                bb->replaceInstruction(copyInst, callInst);
+                return; // Don't erase, we replaced it
+            }
+        }
+
+        // Remove the original copy instruction if no custom copy function
+        toErase.push_back(copyInst);
+    }
+
+    void beforeVisitFunction(gil::Function *func)
+    {
+        // Check if this is a copy function
+        if (func->getName() == "copy") {
+            inCopyFunction = true;
+        }
+
+        // Create context for this function
+        ctx.emplace(module, func, arena);
+    }
+
+    void afterVisitFunction(gil::Function *)
+    {
+        ctx.reset();
+        inCopyFunction = false;
+    }
+};
+
+void PassManager::runCopyLoweringPass()
+{
+    CopyLoweringPass pass(_module, _gilArena);
+    pass.visit(_module);
+}
+
+} // namespace glu::optimizer

lib/Sema/ConstraintSystem/ConcreteTypeVisitor.cpp

@@ -14,7 +14,7 @@ class ConcreteTypeVisitor
 
     bool visitTypeBase(glu::types::TypeBase * /*type*/) { return true; }
 
-    bool visitTypeVariableTy(glu::types::TypeVariableTy *type)
+    bool visitTypeVariableTy([[maybe_unused]] glu::types::TypeVariableTy *type)
     {
         return false; // Type variables are not concrete
     }

lib/Sema/ConstraintSystem/Constraint.cpp

@@ -65,6 +65,7 @@ Constraint::Constraint(
         llvm_unreachable(
             "Wrong constructor for ExpressibleByLiteral constraint"
         );
+    default: llvm_unreachable("Unsupported constraint kind");
     }
 }