From c56877035d6600b463a9cbf0e339f7548c0b46fd Mon Sep 17 00:00:00 2001
From: _ov4 <ov4@ov4.org>
Date: Wed, 21 Oct 2026 05:54:26 +0000
Subject: feat(codegen): instantiate function templates by deduction

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 lib/CodeGen/TemplateClone.cc | 238 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 238 insertions(+)
 create mode 100644 lib/CodeGen/TemplateClone.cc

(limited to 'lib/CodeGen/TemplateClone.cc')

diff --git a/lib/CodeGen/TemplateClone.cc b/lib/CodeGen/TemplateClone.cc
new file mode 100644
index 0000000..7374ee8
--- /dev/null
+++ b/lib/CodeGen/TemplateClone.cc
@@ -0,0 +1,238 @@
+#include "TemplateClone.h"
+#include "cps/FileAST.h"
+#include <cctype>
+
+using namespace cps;
+using namespace cps::detail;
+
+namespace {
+template<class T, class U> std::unique_ptr<T> located(std::unique_ptr<T> Copy, const U *Source) {
+    Copy->setLine(Source->getLine());
+    return Copy;
+}
+}
+
+void TemplateClone::fail(int Line, const std::string &Message) {
+    Failed = true;
+    Error(Line, Message);
+}
+
+std::string TemplateClone::type(const std::string &Name) {
+    size_t Position = 0;
+    auto Join = [](const std::vector<std::string> &Parts) {
+        std::string Result;
+        for (const auto &Part : Parts) {
+            if (!Result.empty()) Result += ',';
+            Result += Part;
+        }
+        return Result;
+    };
+    std::function<std::vector<std::string>()> Parse = [&]() -> std::vector<std::string> {
+        size_t Start = Position;
+        while (Position < Name.size() &&
+               (std::isalnum(static_cast<unsigned char>(Name[Position])) || Name[Position] == '_')) ++Position;
+        if (Position == Start) {
+            fail(0, "Invalid canonical template type " + Name);
+            Position = Name.size();
+            return {};
+        }
+        std::string Base = Name.substr(Start, Position - Start);
+        bool HasArguments = Position < Name.size() && Name[Position] == '<';
+        if (HasArguments) {
+            ++Position;
+            std::vector<std::string> Arguments;
+            while (Position < Name.size() && Name[Position] != '>') {
+                auto Expanded = Parse();
+                Arguments.insert(Arguments.end(), Expanded.begin(), Expanded.end());
+                if (Position == Name.size() || Name[Position] != ',') break;
+                ++Position;
+            }
+            if (Position == Name.size() || Name[Position] != '>') {
+                fail(0, "Invalid canonical template type " + Name);
+                return {};
+            }
+            ++Position;
+            Base += "<" + Join(Arguments) + ">";
+        }
+        bool Expand = Name.compare(Position, 3, "...") == 0;
+        if (Expand) Position += 3;
+        auto Binding = Bindings.find(Base);
+        if (Binding == Bindings.end()) return {Base};
+        if (Expand) return Binding->second;
+        if (Binding->second.size() != 1) {
+            fail(0, "A type pack requires an expansion");
+            return {};
+        }
+        return Binding->second;
+    };
+    auto Types = Parse();
+    if (Position != Name.size()) fail(0, "Invalid canonical template type " + Name);
+    return Join(Types);
+}
+
+std::vector<std::unique_ptr<ExprAST>> TemplateClone::arguments(
+    const std::vector<std::unique_ptr<ExprAST>> &Args) {
+    std::vector<std::unique_ptr<ExprAST>> Result;
+    for (const auto &Arg : Args) {
+        if (auto *Pack = dynamic_cast<PackExpansionExprAST *>(Arg.get())) {
+            auto Names = PackNames.find(Pack->getName());
+            if (Names == PackNames.end()) fail(Pack->getLine(), "Unknown parameter pack " + Pack->getName());
+            else for (const auto &Name : Names->second)
+                Result.push_back(located(std::make_unique<VariableExprAST>(Name), Pack));
+        } else Result.push_back(expression(Arg.get()));
+    }
+    return Result;
+}
+
+std::vector<std::unique_ptr<StmtAST>> TemplateClone::body(
+    const std::vector<std::unique_ptr<StmtAST>> &Body) {
+    std::vector<std::unique_ptr<StmtAST>> Result;
+    for (const auto &Stmt : Body) Result.push_back(statement(Stmt.get()));
+    return Result;
+}
+
+std::unique_ptr<ExprAST> TemplateClone::expression(ExprAST *Expr) {
+    if (!Expr) return nullptr;
+    std::unique_ptr<ExprAST> Copy;
+    if (auto *E = dynamic_cast<IntegerExprAST *>(Expr)) Copy = std::make_unique<IntegerExprAST>(E->getVal());
+    else if (auto *E = dynamic_cast<RealExprAST *>(Expr)) Copy = std::make_unique<RealExprAST>(E->getVal());
+    else if (auto *E = dynamic_cast<BooleanExprAST *>(Expr)) Copy = std::make_unique<BooleanExprAST>(E->getVal());
+    else if (auto *E = dynamic_cast<CharExprAST *>(Expr)) Copy = std::make_unique<CharExprAST>(E->getVal());
+    else if (auto *E = dynamic_cast<StringExprAST *>(Expr)) Copy = std::make_unique<StringExprAST>(E->getVal(), E->isCString());
+    else if (auto *E = dynamic_cast<VariableExprAST *>(Expr)) Copy = std::make_unique<VariableExprAST>(E->getName());
+    else if (auto *E = dynamic_cast<ArrayAccessExprAST *>(Expr)) {
+        std::vector<std::unique_ptr<ExprAST>> Indices;
+        for (const auto &Index : E->getIndices()) Indices.push_back(expression(Index.get()));
+        Copy = std::make_unique<ArrayAccessExprAST>(E->getName(), std::move(Indices), E->getLine());
+    } else if (auto *E = dynamic_cast<UnaryExprAST *>(Expr)) Copy = std::make_unique<UnaryExprAST>(E->getOp(), expression(E->getOperand()));
+    else if (auto *E = dynamic_cast<BinaryExprAST *>(Expr)) Copy = std::make_unique<BinaryExprAST>(E->getOp(), expression(E->getLHS()), expression(E->getRHS()), E->getLine());
+    else if (auto *E = dynamic_cast<CallExprAST *>(Expr)) {
+        std::vector<std::string> Types;
+        for (const auto &Arg : E->getTemplateArgs()) {
+            std::string Substituted = type(Arg);
+            // A template argument pack expands into separate argument slots.
+            size_t Start = 0, Depth = 0;
+            for (size_t I = 0; I <= Substituted.size(); ++I) {
+                if (I < Substituted.size() && Substituted[I] == '<') ++Depth;
+                if (I < Substituted.size() && Substituted[I] == '>') --Depth;
+                if (I == Substituted.size() || (!Depth && Substituted[I] == ',')) {
+                    if (I > Start) Types.push_back(Substituted.substr(Start, I - Start));
+                    Start = I + 1;
+                }
+            }
+        }
+        Copy = std::make_unique<CallExprAST>(E->getCallee(), arguments(E->getArgs()), E->getLine(), std::move(Types));
+    } else if (auto *E = dynamic_cast<MemberCallExprAST *>(Expr)) Copy = std::make_unique<MemberCallExprAST>(expression(E->getReceiver()), E->getMethod(), arguments(E->getArgs()), E->getLine());
+    else if (auto *E = dynamic_cast<NewExprAST *>(Expr)) Copy = std::make_unique<NewExprAST>(type(E->getClassName()), arguments(E->getArgs()), E->getLine());
+    else if (auto *E = dynamic_cast<CastExprAST *>(Expr)) Copy = std::make_unique<CastExprAST>(type(E->getTypeName()), expression(E->getOperand()));
+    else if (auto *E = dynamic_cast<DesignatorExprAST *>(Expr)) {
+        std::vector<DesignatorAccess> Accesses;
+        for (const auto &A : E->getAccesses()) {
+            DesignatorAccess CopyAccess{A.Kind, {}, A.FieldName};
+            for (const auto &Index : A.Indices) CopyAccess.Indices.push_back(expression(Index.get()));
+            Accesses.push_back(std::move(CopyAccess));
+        }
+        Copy = std::make_unique<DesignatorExprAST>(E->getBaseName(), std::move(Accesses), E->getLine());
+    } else if (auto *E = dynamic_cast<AddrOfExprAST *>(Expr)) {
+        auto Target = expression(E->getTarget());
+        Copy = std::make_unique<AddrOfExprAST>(std::unique_ptr<DesignatorExprAST>(static_cast<DesignatorExprAST *>(Target.release())));
+    } else if (dynamic_cast<PackExpansionExprAST *>(Expr)) fail(Expr->getLine(), "A parameter pack expansion is only allowed in an argument list");
+    else fail(Expr->getLine(), "Unsupported expression in template body");
+    if (Copy) Copy->setLine(Expr->getLine());
+    return Copy;
+}
+
+std::unique_ptr<StmtAST> TemplateClone::statement(StmtAST *Stmt) {
+    std::unique_ptr<StmtAST> Copy;
+    if (auto *S = dynamic_cast<DeclareStmtAST *>(Stmt)) Copy = std::make_unique<DeclareStmtAST>(S->getName(), type(S->getType()), arguments(S->getArgs()), S->hasParens());
+    else if (auto *S = dynamic_cast<ArrayDeclareStmtAST *>(Stmt)) {
+        std::vector<std::pair<std::unique_ptr<ExprAST>, std::unique_ptr<ExprAST>>> Bounds;
+        for (const auto &B : S->getBounds()) Bounds.emplace_back(expression(B.first.get()), expression(B.second.get()));
+        Copy = std::make_unique<ArrayDeclareStmtAST>(S->getName(), std::move(Bounds), type(S->getType()));
+    } else if (auto *S = dynamic_cast<ConstantStmtAST *>(Stmt)) Copy = std::make_unique<ConstantStmtAST>(S->getName(), expression(S->getValue()));
+    else if (auto *S = dynamic_cast<AssignStmtAST *>(Stmt)) Copy = std::make_unique<AssignStmtAST>(S->getName(), expression(S->getExpr()));
+    else if (auto *S = dynamic_cast<ArrayAssignStmtAST *>(Stmt)) {
+        std::vector<std::unique_ptr<ExprAST>> Indices;
+        for (const auto &Index : S->getIndices()) Indices.push_back(expression(Index.get()));
+        Copy = std::make_unique<ArrayAssignStmtAST>(S->getName(), std::move(Indices), expression(S->getExpr()), S->getLine());
+    } else if (auto *S = dynamic_cast<DesignatorAssignStmtAST *>(Stmt)) {
+        auto Target = expression(S->getTarget());
+        Copy = std::make_unique<DesignatorAssignStmtAST>(std::unique_ptr<DesignatorExprAST>(static_cast<DesignatorExprAST *>(Target.release())), expression(S->getExpr()));
+    } else if (auto *S = dynamic_cast<InputStmtAST *>(Stmt)) Copy = std::make_unique<InputStmtAST>(expression(S->getTarget()));
+    else if (auto *S = dynamic_cast<DeleteStmtAST *>(Stmt)) Copy = std::make_unique<DeleteStmtAST>(expression(S->getTarget()));
+    else if (auto *S = dynamic_cast<OutputStmtAST *>(Stmt)) {
+        std::vector<std::unique_ptr<ExprAST>> Exprs;
+        for (const auto &E : S->getExprs()) Exprs.push_back(expression(E.get()));
+        Copy = std::make_unique<OutputStmtAST>(std::move(Exprs));
+    } else if (auto *S = dynamic_cast<ReturnStmtAST *>(Stmt)) Copy = std::make_unique<ReturnStmtAST>(expression(S->getRetVal()));
+    else if (auto *S = dynamic_cast<CallStmtAST *>(Stmt)) {
+        CallExprAST Call(S->getCallee(), {}, S->getLine(), S->getTemplateArgs());
+        auto Expr = expression(&Call);
+        auto *Cloned = static_cast<CallExprAST *>(Expr.get());
+        Copy = std::make_unique<CallStmtAST>(S->getCallee(), arguments(S->getArgs()), S->getLine(), Cloned->getTemplateArgs());
+    } else if (auto *S = dynamic_cast<MemberCallStmtAST *>(Stmt)) {
+        auto Call = expression(S->getCall());
+        Copy = std::make_unique<MemberCallStmtAST>(std::unique_ptr<MemberCallExprAST>(static_cast<MemberCallExprAST *>(Call.release())));
+    } else if (auto *S = dynamic_cast<IfStmtAST *>(Stmt)) Copy = std::make_unique<IfStmtAST>(expression(S->getCond()), body(S->getThenStmts()), body(S->getElseStmts()));
+    else if (auto *S = dynamic_cast<WhileStmtAST *>(Stmt)) Copy = std::make_unique<WhileStmtAST>(expression(S->getCond()), body(S->getBody()));
+    else if (auto *S = dynamic_cast<RepeatStmtAST *>(Stmt)) Copy = std::make_unique<RepeatStmtAST>(body(S->getBody()), expression(S->getCond()));
+    else if (auto *S = dynamic_cast<ForStmtAST *>(Stmt)) Copy = std::make_unique<ForStmtAST>(S->getVarName(), expression(S->getStart()), expression(S->getEnd()), expression(S->getStep()), body(S->getBody()));
+    else if (auto *S = dynamic_cast<CaseStmtAST *>(Stmt)) {
+        std::vector<CaseBranch> Branches;
+        for (const auto &B : S->getBranches()) Branches.push_back({expression(B.Lower.get()), expression(B.Upper.get()), body(B.Body), B.Line});
+        Copy = std::make_unique<CaseStmtAST>(S->getSelector(), std::move(Branches));
+    } else if (auto *S = dynamic_cast<TryStmtAST *>(Stmt)) Copy = std::make_unique<TryStmtAST>(body(S->getBody()), body(S->getCatchBody()));
+    else if (dynamic_cast<ThrowStmtAST *>(Stmt)) Copy = std::make_unique<ThrowStmtAST>();
+    else if (auto *S = dynamic_cast<OpenFileStmtAST *>(Stmt)) Copy = std::make_unique<OpenFileStmtAST>(expression(S->getFileName()), S->getMode(), S->getLine());
+    else if (auto *S = dynamic_cast<ReadFileStmtAST *>(Stmt)) Copy = std::make_unique<ReadFileStmtAST>(expression(S->getFileName()), S->getVarName(), S->getLine());
+    else if (auto *S = dynamic_cast<WriteFileStmtAST *>(Stmt)) Copy = std::make_unique<WriteFileStmtAST>(expression(S->getFileName()), expression(S->getData()), S->getLine());
+    else if (auto *S = dynamic_cast<CloseFileStmtAST *>(Stmt)) Copy = std::make_unique<CloseFileStmtAST>(expression(S->getFileName()), S->getLine());
+    else if (dynamic_cast<FunctionDefAST *>(Stmt)) fail(Stmt->getLine(), "Nested FUNCTION or PROCEDURE definitions are not allowed in template bodies");
+    else fail(Stmt->getLine(), "Unsupported declaration in template body");
+    if (Copy) Copy->setLine(Stmt->getLine());
+    return Copy;
+}
+
+std::unique_ptr<FunctionDefAST> TemplateClone::function(const FunctionDefAST *Source,
+    const std::string &Name, const std::string &OwnerClass) {
+    auto SavedNames = PackNames;
+    const auto *Proto = Source->getProto();
+    std::vector<ParamDecl> Params;
+    for (const auto &P : Proto->getParams()) {
+        if (P.IsPack) {
+            auto Binding = Bindings.find(P.TypeName);
+            if (Binding == Bindings.end()) { fail(P.Line, "Unbound template parameter pack"); continue; }
+            auto &Names = PackNames[P.Name];
+            Names.clear();
+            for (size_t I = 0; I < Binding->second.size(); ++I) {
+                ParamDecl Copy = P;
+                Copy.Name += "#" + std::to_string(I + 1);
+                Copy.TypeName = Binding->second[I];
+                Copy.IsPack = false;
+                Names.push_back(Copy.Name);
+                Params.push_back(std::move(Copy));
+            }
+        } else {
+            Params.push_back(P);
+            Params.back().TypeName = type(P.TypeName);
+        }
+    }
+    auto CopyProto = std::make_unique<PrototypeAST>(Name, std::move(Params), type(Proto->getReturnType()),
+        Proto->isExternal(), OwnerClass, Proto->isPublic(), Proto->isOverload());
+    CopyProto->setOperator(Proto->getOperator());
+    CopyProto->setVariadic(Proto->isVariadic());
+    auto Copy = located(std::make_unique<FunctionDefAST>(std::move(CopyProto), body(Source->getBody())), Source);
+    PackNames = std::move(SavedNames);
+    return Failed ? nullptr : std::move(Copy);
+}
+
+std::unique_ptr<ClassTypeDeclAST> TemplateClone::klass(const ClassTypeDeclAST *Source,
+    const std::string &Name) {
+    std::vector<RecordFieldDecl> Fields = Source->getFields();
+    for (auto &Field : Fields) Field.TypeName = type(Field.TypeName);
+    std::vector<std::unique_ptr<FunctionDefAST>> Methods;
+    for (const auto &Method : Source->getMethods())
+        Methods.push_back(function(Method.get(), Method->getProto()->getName(), Name));
+    auto Copy = located(std::make_unique<ClassTypeDeclAST>(Name, std::move(Fields), std::move(Methods)), Source);
+    return Failed ? nullptr : std::move(Copy);
+}
-- 
cgit v1.3.1-4-g156e