From 16231050058131860f710073c17d3bca7c6637eb Mon Sep 17 00:00:00 2001 From: _ov4 Date: Sun, 18 Oct 2026 06:05:53 +0000 Subject: feat(operators): support global binary operator overloads Resolve exact operand types and preserve declared operator return types. Reject implicit STRING to BOOLEAN conversion at typed expression boundaries. Co-Authored-By: Claude Opus 5.5 --- lib/CodeGen/ControlFlowGen.cc | 8 ++++++++ lib/CodeGen/ExpressionGen.cc | 11 +++++++++++ lib/CodeGen/FunctionGen.cc | 23 +++++++++++++++++++++++ lib/CodeGen/OperatorGen.cc | 20 ++++++++++++++++++++ lib/CodeGen/TypeCheckGen.cc | 4 ++++ lib/CodeGen/ValueTypeGen.cc | 8 ++++++-- lib/Lexer/Lexer.cc | 1 + lib/Parser/ParserFunction.cc | 31 ++++++++++++++++++++++++++++--- 8 files changed, 101 insertions(+), 5 deletions(-) create mode 100644 lib/CodeGen/OperatorGen.cc (limited to 'lib') diff --git a/lib/CodeGen/ControlFlowGen.cc b/lib/CodeGen/ControlFlowGen.cc index 17f43f2..0cf0c34 100644 --- a/lib/CodeGen/ControlFlowGen.cc +++ b/lib/CodeGen/ControlFlowGen.cc @@ -204,6 +204,14 @@ void CodeGen::emitCaseStmt(CaseStmtAST *Stmt) { return nullptr; } Value *LabelValue = emitExpr(Label); + auto Overload = resolveOperator(Op, SelectorType, LabelType); + if (Overload.Signature && !Overload.Ambiguous) { + const TypeInfo *Result = resolveType(Overload.Signature->ReturnTypeName); + if (!Result || Result->Kind != TypeKind::Boolean) { + reportError("CASE comparison must return BOOLEAN"); + return nullptr; + } + } return emitBinaryOp(Op, Selected, SelectorType, LabelValue, LabelType, Branch.Line); }; if (!Branch.Lower) { diff --git a/lib/CodeGen/ExpressionGen.cc b/lib/CodeGen/ExpressionGen.cc index 79c5fb0..8fb13c9 100644 --- a/lib/CodeGen/ExpressionGen.cc +++ b/lib/CodeGen/ExpressionGen.cc @@ -4,6 +4,7 @@ #include "cps/MemoryHandler.h" #include "cps/Lexer.h" #include "cps/TypeAST.h" +#include "cps/Operator.h" #include "Builtins.h" #include #include @@ -155,6 +156,16 @@ Value *CodeGen::emitBinaryOp(int Op, Value *L, const TypeInfo *LT, Value *R, const TypeInfo *RT, int Line) { SaveAndRestore Location(DiagnosticLine, Line ? Line : DiagnosticLine); if (!L || !R) return nullptr; + if (!LT || !RT) { + reportError("Cannot determine operand types for %s", operatorName(Op).c_str()); + return nullptr; + } + auto Overload = resolveOperator(Op, LT, RT); + if (Overload.Ambiguous) { + reportError("Ambiguous overload for %s(%s, %s)", operatorName(Op).c_str(), LT->Name.c_str(), RT->Name.c_str()); + return nullptr; + } + if (Overload.Signature) return FuncGen->emitCall(*Overload.Signature, {L, R}); if ((LT && LT->isC()) || (RT && RT->isC())) return emitCBinaryOp(Op, L, LT, R, RT, Line); if ((LT && LT->isUserKind()) || (RT && RT->isUserKind())) diff --git a/lib/CodeGen/FunctionGen.cc b/lib/CodeGen/FunctionGen.cc index 9559717..bccf397 100644 --- a/lib/CodeGen/FunctionGen.cc +++ b/lib/CodeGen/FunctionGen.cc @@ -2,6 +2,7 @@ #include "cps/FunctionGen.h" #include "cps/CodeGen.h" #include "cps/ExceptionHandler.h" +#include "cps/Operator.h" #include #include @@ -122,6 +123,28 @@ const FuncSig *FunctionGen::getSignatureByLink(const std::string &Name) const { Function *FunctionGen::emitPrototype(PrototypeAST *Proto) { auto Registered = PrototypeLinks.find(Proto); if (Registered != PrototypeLinks.end()) return Module.getFunction(Registered->second); + if (int Op = Proto->getOperator()) { + size_t Count = Proto->getParams().size() + !Proto->getOwnerClass().empty(); + bool ValidCount = Op == '-' ? Count == 1 || Count == 2 + : Op == tok_not ? Count == 1 : Count == 2; + if (!ValidCount) { + reportError("Invalid operand count for %s", Proto->getName().c_str()); + return nullptr; + } + bool HasUserOperand = !Proto->getOwnerClass().empty(); + for (const auto &P : Proto->getParams()) { + if (P.IsArray) { + reportError("An operator parameter cannot be a whole array"); + return nullptr; + } + const TypeInfo *T = Types.resolve(P.TypeName); + HasUserOperand |= T && (T->isRecord() || T->isEnum()); + } + if (!HasUserOperand) { + reportError("%s requires a record, class or enum operand", Proto->getName().c_str()); + return nullptr; + } + } if (Proto->isOverload() && Proto->getOwnerClass().empty() && sameIdentifier(Proto->getName(), "MAIN")) { reportError("MAIN cannot be declared OVERLOAD"); return nullptr; diff --git a/lib/CodeGen/OperatorGen.cc b/lib/CodeGen/OperatorGen.cc new file mode 100644 index 0000000..83c515b --- /dev/null +++ b/lib/CodeGen/OperatorGen.cc @@ -0,0 +1,20 @@ +#include "cps/CodeGen.h" +#include "cps/Operator.h" + +using namespace cps; + +// Probing candidates must not evaluate operands or diagnose absent overloads: +// both static typing and emission use this same selection. +CodeGen::OperatorResolution CodeGen::resolveOperator( + int Op, const TypeInfo *Left, const TypeInfo *Right) { + OperatorResolution Result; + if (!Left) return Result; + for (const FuncSig *Sig : FuncGen->getOverloads(operatorName(Op))) { + if (Sig->Prototype->getOperator() != Op || Sig->Params.size() != (Right ? 2u : 1u)) continue; + if (!Left->sameType(resolveType(Sig->Params[0].TypeName))) continue; + if (Right && !Right->sameType(resolveType(Sig->Params[1].TypeName))) continue; + if (Result.Signature) Result.Ambiguous = true; + else Result.Signature = Sig; + } + return Result; +} diff --git a/lib/CodeGen/TypeCheckGen.cc b/lib/CodeGen/TypeCheckGen.cc index 690d005..5d014f6 100644 --- a/lib/CodeGen/TypeCheckGen.cc +++ b/lib/CodeGen/TypeCheckGen.cc @@ -46,6 +46,10 @@ Value *CodeGen::emitCoercedExpr(ExprAST *E, const TypeInfo *Target) { } const TypeInfo *Src = getExprTypeInfo(E); + if (Src && Src->Kind == TypeKind::String && Target->Kind == TypeKind::Boolean) { + reportError("Cannot implicitly convert STRING to BOOLEAN"); + return nullptr; + } if (Target->isC() || (Src && Src->isC())) { if (auto *Addr = dynamic_cast(E)) { diff --git a/lib/CodeGen/ValueTypeGen.cc b/lib/CodeGen/ValueTypeGen.cc index 3c1fc06..b09a5d9 100644 --- a/lib/CodeGen/ValueTypeGen.cc +++ b/lib/CodeGen/ValueTypeGen.cc @@ -81,6 +81,12 @@ const TypeInfo *CodeGen::getExprTypeInfo(ExprAST *Expr) { } if (auto *Bin = dynamic_cast(Expr)) { + const TypeInfo *L = getExprTypeInfo(Bin->getLHS()); + const TypeInfo *R = getExprTypeInfo(Bin->getRHS()); + if (!L || !R || isWholeArrayVar(Bin->getLHS()) || isWholeArrayVar(Bin->getRHS())) return nullptr; + auto Overload = resolveOperator(Bin->getOp(), L, R); + if (Overload.Ambiguous) return nullptr; + if (Overload.Signature) return resolveType(Overload.Signature->ReturnTypeName); switch (Bin->getOp()) { case tok_eq: case tok_ne: @@ -99,8 +105,6 @@ const TypeInfo *CodeGen::getExprTypeInfo(ExprAST *Expr) { break; } - const TypeInfo *L = getExprTypeInfo(Bin->getLHS()); - const TypeInfo *R = getExprTypeInfo(Bin->getRHS()); if ((L && L->isC()) || (R && R->isC())) return Types->commonCScalar(L, R); // Enum arithmetic: E +/- INTEGER (enum on the left) yields the enum; // every other user-kind combination has no type (emission rejects it). diff --git a/lib/Lexer/Lexer.cc b/lib/Lexer/Lexer.cc index 8f906ae..cebf335 100644 --- a/lib/Lexer/Lexer.cc +++ b/lib/Lexer/Lexer.cc @@ -134,6 +134,7 @@ int Lexer::readToken() { if (IdentifierStr == "OR") return tok_or; if (IdentifierStr == "NOT") return tok_not; + if (IdentifierStr == "OPERATOR") return tok_operator; if (IdentifierStr == "OVERLOAD") return tok_overload; if (IdentifierStr == "FUNCTION") return tok_function; if (IdentifierStr == "ENDFUNCTION") return tok_endfunction; diff --git a/lib/Parser/ParserFunction.cc b/lib/Parser/ParserFunction.cc index 7686f51..3ff54da 100644 --- a/lib/Parser/ParserFunction.cc +++ b/lib/Parser/ParserFunction.cc @@ -1,6 +1,7 @@ #include "cps/Diagnostics.h" #include "cps/Parser.h" #include "cps/FunctionAST.h" +#include "cps/Operator.h" #include using namespace cps; @@ -130,6 +131,18 @@ std::optional> Parser::ParsePrototypeArgs(bool AllowByRef return Params; } +std::string Parser::ParseOperatorName(int &Op) { + getNextToken(); // OPERATOR + Op = CurTok; + if (operatorSpelling(Op).empty()) { + sourceDiagnostic(Lex.getLine(), "error: Expected a supported operator after OPERATOR at line %d\n", Lex.getLine()); + getNextToken(); + return {}; + } + getNextToken(); + return operatorName(Op); +} + std::unique_ptr Parser::ParseFunction(const std::string &OwnerClass, bool IsPublic, bool IsOverload) { int Line = Lex.getLine(); getNextToken(); @@ -141,13 +154,24 @@ std::unique_ptr Parser::ParseFunction(const std::string &OwnerCl cps::sourceDiagnostic(Lex.getLine(), "error: constructor NEW must be a PROCEDURE at line %d\n", Line); return nullptr; } - if (CurTok != tok_identifier) { + if (CurTok != tok_identifier && CurTok != tok_operator) { cps::sourceDiagnostic(Lex.getLine(), "error: Expected function name\n"); return nullptr; } - std::string Name = Lex.IdentifierStr; - getNextToken(); + int Operator = 0; + std::string Name; + if (CurTok == tok_operator) { + Name = ParseOperatorName(Operator); + if (Name.empty()) return nullptr; + if (!IsOverload) { + sourceDiagnostic(Line, "error: An operator function must be declared OVERLOAD at line %d\n", Line); + return nullptr; + } + } else { + Name = Lex.IdentifierStr; + getNextToken(); + } auto Args = ParsePrototypeArgs(/*AllowByRef=*/false); if (!Args) return nullptr; @@ -168,6 +192,7 @@ std::unique_ptr Parser::ParseFunction(const std::string &OwnerCl } auto Proto = std::make_unique(Name, std::move(*Args), RetType, false, OwnerClass, IsPublic, IsOverload); + Proto->setOperator(Operator); std::vector> Body = ParseBlock({tok_endfunction}); -- cgit v1.3.1-4-g156e