feat: whole arrays (and records) as FUNCTION/PROCEDURE parameters

- Parameter syntax lands end-to-end: ARRAY OF T (rank 1, bounds travel
  with the argument) and ARRAY[l:u,...] OF T (any rank, literal bounds as
  a checked contract). Element type and rank must match exactly.
- Flattened ABI: each rank-R array parameter becomes a data pointer plus
  kBoundArgsPerDim i64 bounds per dimension. The callee rebuilds
  ArrayMetadata from those bounds (ArrayHandler::bindArrayParameter via a
  binder callback injected by CodeGen, so FunctionGen stays ignorant of
  the array subsystem); the checked-indexing pipeline is reused unchanged.
- BYVAL (the CIE default) copies the whole buffer at callee entry
  (malloc+memcpy, never freed — consistent with the string policy) so
  callee writes stay invisible; BYREF binds the caller's buffer.
- Bounded-parameter contract: compile-time comparison when the caller's
  bounds are constants, else a runtime [Fatal] check
  (RuntimeCheck::emitArrayArgBoundsCheck).
- marshalCallArgs gains the array branch and a call-site line number
  (CallStmtAST now carries one); whole-array-to-scalar keeps a clear
  error, FUNCTION RETURNS ARRAY is a dedicated parse error.
- Verified: BYREF fill/sort-style mutation, BYVAL copy invisibility,
  2-D bounded params, ARRAY OF <record> with field writes through the
  parameter, bounds-contract mismatches at compile time and run time.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

1 files changed, 34 insertions, 4 deletions

diff --git a/include/cps/FunctionGen.h b/include/cps/FunctionGen.h
index 9bb6eef..d914162 100644
--- a/include/cps/FunctionGen.h
+++ b/include/cps/FunctionGen.h
@@ -3,23 +3,50 @@
 #include "llvm/IR/Module.h"
 #include "cps/FunctionAST.h"
 #include "cps/TypeSystem.h"
+#include <cstdint>
 #include <map>
+#include <utility>
 #include <vector>
 #include <functional>
 #include <string>
-#include <tuple>
 
 namespace cps {
 
+// Array-parameter ABI: each rank-R array parameter is flattened into the
+// data pointer followed by kBoundArgsPerDim i64 bounds per dimension.
+inline constexpr unsigned kBoundArgsPerDim = 2; // lower, upper
+inline constexpr const char *kLowerBoundSuffix = ".lb";
+inline constexpr const char *kUpperBoundSuffix = ".ub";
+
+// Pseudocode-level signature of one FUNCTION/PROCEDURE parameter; for arrays
+// TypeName is the ELEMENT type and DeclaredBounds mirrors ParamDecl.
+struct ParamSig {
+    std::string TypeName;
+    bool IsByRef = false;
+    bool IsArray = false;
+    int Rank = 0;
+    std::vector<std::pair<int64_t, int64_t>> DeclaredBounds;
+};
+
 // Pseudocode-level signature of a FUNCTION/PROCEDURE, kept so call sites can
-// dispatch on declared parameter types and BYREF flags instead of inferring
-// them back from LLVM types.
+// dispatch on declared parameter types and modes instead of inferring them
+// back from LLVM types.
 struct FuncSig {
     std::string ReturnTypeName;
-    std::vector<std::pair<std::string, bool>> Params; // (TypeName, IsByRef)
+    std::vector<ParamSig> Params;
 };
 
 class FunctionGen {
+public:
+    // Injected by CodeGen (StmtEmitter inversion precedent) so array
+    // parameters can be bound into ArrayHandler without FunctionGen ever
+    // seeing it: (param, incoming data ptr, per-dim lower/upper bounds).
+    using ArrayParamBinder =
+        std::function<void(const ParamDecl &, llvm::Value *,
+                           const std::vector<llvm::Value*> &,
+                           const std::vector<llvm::Value*> &)>;
+
+private:
     llvm::LLVMContext &Context;
     llvm::Module &Module;
     llvm::IRBuilder<> &Builder;
@@ -29,6 +56,7 @@ class FunctionGen {
     bool &HadError;
 
     std::map<std::string, FuncSig> Signatures;
+    ArrayParamBinder BindArrayParam;
 
     void createArgumentAllocas(llvm::Function *F, const std::vector<ParamDecl> &Params);
 
@@ -43,6 +71,8 @@ public:
 
     llvm::Type *getLLVMType(const std::string &TypeName);
 
+    void setArrayParamBinder(ArrayParamBinder Binder) { BindArrayParam = std::move(Binder); }
+
     const FuncSig *getSignature(const std::string &Name) const;
 
     llvm::Function *emitPrototype(PrototypeAST *Proto);