Signed/unsigned overloads collapse to the same Mojo signature (duplicate-definition)

[Tokarzewski]

Severity: medium (found stress-testing against Topologic, #79)

int and unsigned int both map to Mojo's Int (and presumably Rust's i64/Zig's equivalent). When a C++ class overloads a method by signedness only, both overloads survive into the emitted target with an identical signature — a guaranteed duplicate-definition compile error.

Repro (from github.com/wassimj/Topologic, TopologicCore/include/Bitwise.h):

class Bitwise {
public:
    static int NOT(const int kArgument1);
    static unsigned int NOT(const unsigned int kArgument1);
};

transpile --source cpp --target mojo on the flattened header+source emits:

struct Bitwise(Copyable, Movable):
    def NOT(self, kArgument1: Int) -> Int:
        return -kArgument1

    def NOT(self, kArgument1: Int) -> Int:
        return -kArgument1

Two methods with the identical (Int) -> Int signature in the same struct — Mojo (and Rust/Zig, which don't support overloading by signedness either) will reject this as a redefinition.

Fix direction

Detect same-name methods/functions in a struct/module whose parameter+return signatures collapse to identical target types after the int/unsigned int → single-int-type simplification, and either:

• rename the losing overload deterministically (e.g. suffix _u/_unsigned), or
• refuse the construct (raise UnsupportedConstruct) rather than silently emitting code that won't compile — consistent with this project's stated "refuse rather than emit wrong code" philosophy.

Found via corpus-testing PR (branch claude/repo-review-n4ylcz) which also fixed several parser-level gaps (export-macro handling, std::list shim, header-guard stripping) surfaced by the same corpus.

[Tokarzewski]

Status update (2026-07-12)

The duplicate-definition root cause is now addressed at the data layer by the new codebase-memory-mcp-backed preamble helper (src/transpilers/frontends/cpp/parser/cbmpreamble.py).

Root cause recap: CPP_TYPE_ALIASES collapses int / unsigned int / all width+signedness spellings onto one "int", so Bitwise::NOT(int) and Bitwise::NOT(unsigned int) both became (Int)->Int in Mojo and emitted two identical signatures.

Fix (data layer): the cbm graph recovers the real, distinct param_types per method, and cbmpreamble.payload_to_cpp emits each overload verbatim (one declaration per distinct (parent, name, param_types) triple). The regression test tests/test_cbm_preamble.py::test_overload_payload_emits_two_distinct_decls pins it: two NOT overloads survive as two distinct signatures.

Companion backend dedup (pre-existing, test_dedupe_overloads.py) now passes after the clang-version preamble fix (#2) — was environmentally red on the too-new ROCm clang 21; size_t must be unsigned long long and operator new/using std:: conflicts removed from the preamble.

Caveat: this recovers the overload distinction into the HIR. The Mojo/Rust backend still needs to decide Int vs UInt or rename — that decision lives in the backend dedupe_overloads pass, which is the other half. The data layer no longer silently merges them.