feat(parser): parse OVERLOAD prefix on FUNCTION and PROCEDURE

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

3 files changed, 25 insertions, 10 deletions

diff --git a/lib/Parser/Parser.cc b/lib/Parser/Parser.cc
index d4dd18e..f7817ec 100644
--- a/lib/Parser/Parser.cc
+++ b/lib/Parser/Parser.cc
@@ -50,7 +50,7 @@ void Parser::syncToStatementStart() {
         case tok_delete: case tok_constant: case tok_declare: case tok_identifier: case tok_input: case tok_output:
         case tok_case: case tok_endcase: case tok_otherwise:
         case tok_if: case tok_while: case tok_repeat: case tok_for:
-        case tok_function: case tok_procedure: case tok_call: case tok_return:
+        case tok_overload: case tok_function: case tok_procedure: case tok_call: case tok_return:
         case tok_else: case tok_endif: case tok_endwhile: case tok_until:
         case tok_next: case tok_endfunction: case tok_endprocedure:
         case tok_openfile: case tok_readfile: case tok_writefile: case tok_closefile:
@@ -212,6 +212,14 @@ std::unique_ptr<StmtAST> Parser::ParseStatementImpl() {
     else if (CurTok == tok_for) {
         return ParseForStmt();
     }
+    else if (CurTok == tok_overload) {
+        int Line = Lex.getLine();
+        getNextToken();
+        if (CurTok == tok_function) return ParseFunction({}, true, true);
+        if (CurTok == tok_procedure) return ParseProcedure({}, true, true);
+        cps::sourceDiagnostic(Line, "error: OVERLOAD must be followed by FUNCTION or PROCEDURE at line %d\n", Line);
+        return nullptr;
+    }
     else if (CurTok == tok_function) {
         return ParseFunction();
     }
diff --git a/lib/Parser/ParserFunction.cc b/lib/Parser/ParserFunction.cc
index fa46dcf..3df324c 100644
--- a/lib/Parser/ParserFunction.cc
+++ b/lib/Parser/ParserFunction.cc
@@ -130,7 +130,7 @@ std::optional<std::vector<ParamDecl>> Parser::ParsePrototypeArgs(bool AllowByRef
     return Params;
 }
 
-std::unique_ptr<FunctionDefAST> Parser::ParseFunction(const std::string &OwnerClass, bool IsPublic) {
+std::unique_ptr<FunctionDefAST> Parser::ParseFunction(const std::string &OwnerClass, bool IsPublic, bool IsOverload) {
     int Line = Lex.getLine();
     getNextToken();
     if (CurTok == tok_delete || (CurTok == tok_identifier && sameIdentifier(Lex.IdentifierStr, "DELETE"))) {
@@ -167,7 +167,7 @@ std::unique_ptr<FunctionDefAST> Parser::ParseFunction(const std::string &OwnerCl
         }
     }
 
-    auto Proto = std::make_unique<PrototypeAST>(Name, std::move(*Args), RetType, false, OwnerClass, IsPublic);
+    auto Proto = std::make_unique<PrototypeAST>(Name, std::move(*Args), RetType, false, OwnerClass, IsPublic, IsOverload);
 
     std::vector<std::unique_ptr<StmtAST>> Body = ParseBlock({tok_endfunction});
 
@@ -182,7 +182,7 @@ std::unique_ptr<FunctionDefAST> Parser::ParseFunction(const std::string &OwnerCl
     return Def;
 }
 
-std::unique_ptr<FunctionDefAST> Parser::ParseProcedure(const std::string &OwnerClass, bool IsPublic) {
+std::unique_ptr<FunctionDefAST> Parser::ParseProcedure(const std::string &OwnerClass, bool IsPublic, bool IsOverload) {
     int Line = Lex.getLine();
     getNextToken();
     if (CurTok != tok_identifier && CurTok != tok_new && CurTok != tok_delete) {
@@ -207,7 +207,7 @@ std::unique_ptr<FunctionDefAST> Parser::ParseProcedure(const std::string &OwnerC
         cps::sourceDiagnostic(Lex.getLine(), "error: destructor DELETE must have no parameters at line %d\n", Line);
         return nullptr;
     }
-    auto Proto = std::make_unique<PrototypeAST>(Name, std::move(*Args), "VOID", false, OwnerClass, IsPublic);
+    auto Proto = std::make_unique<PrototypeAST>(Name, std::move(*Args), "VOID", false, OwnerClass, IsPublic, IsOverload);
 
     std::vector<std::unique_ptr<StmtAST>> Body = ParseBlock({tok_endprocedure});
 
diff --git a/lib/Parser/ParserType.cc b/lib/Parser/ParserType.cc
index b67558f..d281293 100644
--- a/lib/Parser/ParserType.cc
+++ b/lib/Parser/ParserType.cc
@@ -116,7 +116,7 @@ std::optional<std::vector<RecordFieldDecl>> Parser::ParseRecordBody(
     const char *EndKeyword = IsClass ? "ENDCLASS" : "ENDTYPE";
     auto AtField = [&] {
         return IsClass ? (CurTok == tok_public || CurTok == tok_private || CurTok == tok_identifier ||
-                            CurTok == tok_function || CurTok == tok_procedure)
+                            CurTok == tok_overload || CurTok == tok_function || CurTok == tok_procedure)
                        : CurTok == tok_declare;
     };
     std::vector<RecordFieldDecl> Fields;
@@ -126,11 +126,18 @@ std::optional<std::vector<RecordFieldDecl>> Parser::ParseRecordBody(
             // Class fields default to public, like record fields.
             bool IsPublic = CurTok != tok_private;
             if (IsClass && (CurTok == tok_public || CurTok == tok_private) &&
-                (Lex.peekToken() == tok_function || Lex.peekToken() == tok_procedure))
+                (Lex.peekToken() == tok_overload || Lex.peekToken() == tok_function || Lex.peekToken() == tok_procedure))
                 getNextToken();
-            if (IsClass && (CurTok == tok_function || CurTok == tok_procedure)) {
-                auto Method = CurTok == tok_function ? ParseFunction(Name, IsPublic)
-                                                    : ParseProcedure(Name, IsPublic);
+            if (IsClass && (CurTok == tok_overload || CurTok == tok_function || CurTok == tok_procedure)) {
+                bool IsOverload = CurTok == tok_overload;
+                if (IsOverload) getNextToken();
+                if (CurTok != tok_function && CurTok != tok_procedure) {
+                    cps::sourceDiagnostic(Lex.getLine(), "error: OVERLOAD must be followed by FUNCTION or PROCEDURE at line %d\n", Lex.getLine());
+                    HadFieldError = true;
+                    continue;
+                }
+                auto Method = CurTok == tok_function ? ParseFunction(Name, IsPublic, IsOverload)
+                                                    : ParseProcedure(Name, IsPublic, IsOverload);
                 if (Method && Methods) {
                     Methods->push_back(std::move(Method));
                     continue;