Fix Bugzilla Issue 22688 - disambiguate module and struct mangling by zero-padding modules

Author: CHIKI Badreddine

compiler/src/dmd/mangle/package.d

@@ -567,7 +567,17 @@ public:
             }
             else if (p.getIdent())
             {
-                mangleIdentifier(p.ident, s);
+                /* Use a leading zero in the length prefix for packages and modules
+                 * to disambiguate them from other parent symbols (e.g. structs, classes, enums).
+                 * For example, module `bar` is mangled as `03bar` while
+                 * struct `bar` stays as `3bar`. Leading zeros don't change
+                 * the numeric value, so existing demanglers handle this
+                 * correctly.
+                 * See: https://github.com/dlang/dmd/issues/22688
+                 */
+                const zeroPad = (p.isModule() !is null) || (p.isPackage() !is null);
+                if (!backref.addRefToIdentifier(*buf, p.ident))
+                    toBuffer(*buf, p.ident.toString(), s, zeroPad);
                 if (FuncDeclaration f = p.isFuncDeclaration())
                     mangleFunc(f, true);
             }
@@ -1225,15 +1235,23 @@ void writeBackRef(ref OutBuffer buf, size_t pos) @safe
 
 /************************************************************
  * Write length prefixed string to buf.
+ * Params:
+ *      buf = buffer to write to
+ *      id = identifier string to write
+ *      s = symbol for error reporting
+ *      zeroPad = if true, prefix the length with a leading '0'
+ *          to disambiguate non-module symbols from modules
  */
 private
-extern (D) void toBuffer(ref OutBuffer buf, const(char)[] id, Dsymbol s)
+extern (D) void toBuffer(ref OutBuffer buf, const(char)[] id, Dsymbol s, bool zeroPad = false)
 {
     const len = id.length;
     if (buf.length + len >= 8 * 1024 * 1024) // 8 megs ought be enough for anyone
         error(s.loc, "%s `%s` excessive length %llu for symbol, possible recursive expansion?", s.kind, s.toPrettyChars, cast(ulong)(buf.length + len));
     else
     {
+        if (zeroPad)
+            buf.writeByte('0');
         buf.print(len);
         buf.writestring(id);
     }

compiler/test/runnable/imports/issue22688/bar.d

@@ -0,0 +1,3 @@
+module issue22688.bar;
+
+int zen() => 1;

compiler/test/runnable/imports/issue22688/package.d

@@ -0,0 +1,28 @@
+module issue22688;
+
+import issue22688.bar;
+
+struct bar
+{
+    static int zen() => 2;
+}
+
+void test22688()
+{
+    // The module function and the struct function must have
+    // different mangled names to avoid linker collisions.
+    // The struct parent component gets a leading zero prefix:
+    // module bar -> "3bar", struct bar -> "03bar".
+    static assert(zen.mangleof != bar.zen.mangleof,
+        "Module and struct functions must have different mangles");
+
+    // Module-level zen: issue22688.bar.zen (bar is a module)
+    // Struct-level zen: issue22688.bar.zen (bar is a struct, gets leading zero)
+    static assert(zen.mangleof == "_D10issue226883bar3zenFZi",
+        "Module function zen should use normal module mangling");
+    static assert(bar.zen.mangleof == "_D10issue2268803bar3zenFZi",
+        "Struct function zen should use zero-padded struct mangling");
+
+    assert(zen() == 1);
+    assert(bar.zen() == 2);
+}

compiler/test/runnable/issue22688.d

@@ -0,0 +1,10 @@
+// EXTRA_FILES: imports/issue22688/package.d imports/issue22688/bar.d
+
+module issue22688_test;
+
+import issue22688;
+
+void main()
+{
+    test22688();
+}