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, 7 insertions, 1 deletions

diff --git a/lib/Parser/ParserFunction.cc b/lib/Parser/ParserFunction.cc
index a46cd0f..776a980 100644
--- a/lib/Parser/ParserFunction.cc
+++ b/lib/Parser/ParserFunction.cc
@@ -135,6 +135,11 @@ std::unique_ptr<StmtAST> Parser::ParseFunction() {
     std::string RetType = "INTEGER";
     if (CurTok == tok_returns) {
         getNextToken();
+        if (CurTok == tok_array) {
+            fprintf(stderr, "Error: A FUNCTION cannot RETURN an array; use a BYREF PROCEDURE parameter instead at line %d\n",
+                    Lex.getLine());
+            return nullptr;
+        }
         RetType = ParseTypeName(true);
         if (RetType.empty()) {
             fprintf(stderr, "Error: Expected return type for function '%s'\n", Name.c_str());
@@ -181,6 +186,7 @@ std::unique_ptr<StmtAST> Parser::ParseProcedure() {
 }
 
 std::unique_ptr<StmtAST> Parser::ParseCallStmt() {
+    int Line = Lex.getLine();
     getNextToken();
     if (CurTok != tok_identifier) {
         fprintf(stderr, "Error: Expected callee name after CALL\n");
@@ -198,7 +204,7 @@ std::unique_ptr<StmtAST> Parser::ParseCallStmt() {
         Args = std::move(*Parsed);
     }
 
-    return std::make_unique<CallStmtAST>(Callee, std::move(Args));
+    return std::make_unique<CallStmtAST>(Callee, std::move(Args), Line);
 }
 
 std::unique_ptr<StmtAST> Parser::ParseReturnStmt() {