Fix issue 18095 - Add support for pragma(mangle) on alias declarations

This allows to override the mangling of a type in an alias
declaration as follows:

```d
pragma(mangle, "foo") alias foo = int;
static assert(foo.mangleof == "foo");
static assert(int.mangleof == "i");
```

Overriding the mangling of a type in an alias allows for more generic
solution to get the correct mangling of `c_long/c_ulong` for C++
functions. With the current solution the compiler is looking for a
struct with the name `__c_long/__c_ulong` and special cases the
mangling for that particular struct. Since D doesn't have implicit
conversions to structs one are also forced cast/explicitly construct a
`__c_long` struct when calling a function which uses the `__c_long`
type as a parameter. With an alias that's not necessary anymore.

Author: jacob-carlborg

src/dmd/cppmangle.d

@@ -735,7 +735,12 @@ public:
         else
         {
             // For value types, strip const/immutable/shared from the head of the type
-            t.mutableOf().unSharedOf().accept(this);
+            auto unqualified = t.mutableOf().unSharedOf();
+
+            if (unqualified.mangleOverride)
+                buf.writestring(unqualified.mangleOverride);
+            else
+                unqualified.accept(this);
         }
     }
 

src/dmd/dmangle.d

@@ -267,7 +267,9 @@ public:
 
     final void mangleType(Type t)
     {
-        if (!backrefType(t))
+        if (t.mangleOverride)
+            buf.writestring(t.mangleOverride);
+        else if (!backrefType(t))
             t.accept(this);
     }
 
@@ -1105,7 +1107,9 @@ extern (C++) const(char)* mangleExact(FuncDeclaration fd)
 
 extern (C++) void mangleToBuffer(Type t, OutBuffer* buf)
 {
-    if (t.deco)
+    if (t.mangleOverride)
+        buf.writestring(t.mangleOverride);
+    else if (t.deco)
         buf.writestring(t.deco);
     else
     {

src/dmd/dsymbolsem.d

@@ -77,7 +77,7 @@ import dmd.visitor;
 
 enum LOG = false;
 
-private uint setMangleOverride(Dsymbol s, char* sym)
+private uint setMangleOverride(Dsymbol s, char* sym, Scope* sc)
 {
     AttribDeclaration ad = s.isAttribDeclaration();
     if (ad)
@@ -86,12 +86,16 @@ private uint setMangleOverride(Dsymbol s, char* sym)
         uint nestedCount = 0;
         if (decls && decls.dim)
             for (size_t i = 0; i < decls.dim; ++i)
-                nestedCount += setMangleOverride((*decls)[i], sym);
+                nestedCount += setMangleOverride((*decls)[i], sym, sc);
         return nestedCount;
     }
-    else if (s.isFuncDeclaration() || s.isVarDeclaration())
+    else if (s.isFuncDeclaration() || s.isVarDeclaration() || s.isAliasDeclaration)
     {
         s.isDeclaration().mangleOverride = sym;
+
+        if (s.isAliasDeclaration)
+            semantic2(s, sc);
+
         return 1;
     }
     else
@@ -382,6 +386,19 @@ extern(C++) final class Semantic2Visitor : Visitor
         }
     }
 
+    override void visit(AliasDeclaration ad)
+    {
+        //printf("AliasDeclaration.semantic2 %s\n", ad.toChars);
+
+        if (!ad.mangleOverride || ad.type.mangleOverride)
+            return;
+
+        // make a copy to make sure the mangling of the original type isn't
+        // overwritten
+        ad.type = ad.type.copy();
+        ad.type.mangleOverride = ad.mangleOverride;
+    }
+
     override void visit(Import i)
     {
         //printf("Import::semantic2('%s')\n", toChars());
@@ -2915,7 +2932,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
     override void visit(PragmaDeclaration pd)
     {
         // Should be merged with PragmaStatement
-        //printf("\tPragmaDeclaration::semantic '%s'\n", pd.toChars());
+        //printf("PragmaDeclaration::semantic '%s'\n", pd.toChars());
         if (pd.ident == Id.msg)
         {
             if (pd.args)
@@ -3126,7 +3143,7 @@ private extern(C++) final class DsymbolSemanticVisitor : Visitor
                         char* name = cast(char*)mem.xmalloc(se.len + 1);
                         memcpy(name, se.string, se.len);
                         name[se.len] = 0;
-                        uint cnt = setMangleOverride(s, name);
+                        uint cnt = setMangleOverride(s, name, sc2);
                         if (cnt > 1)
                             pd.error("can only apply to a single declaration");
                     }
@@ -7016,7 +7033,7 @@ Laftersemantic:
 // function used to perform semantic on AliasDeclaration
 void aliasSemantic(AliasDeclaration ds, Scope* sc)
 {
-    //printf("AliasDeclaration::semantic() %s\n", toChars());
+    //printf("AliasDeclaration::semantic() %s\n", ds.toChars());
     if (ds.aliassym)
     {
         auto fd = ds.aliassym.isFuncLiteralDeclaration();

src/dmd/expressionsem.d

@@ -9428,7 +9428,17 @@ extern (C++) Expression expressionSemantic(Expression e, Scope* sc)
 
 Expression semanticX(DotIdExp exp, Scope* sc)
 {
-    //printf("DotIdExp::semanticX(this = %p, '%s')\n", this, toChars());
+    static Expression mangleToBuffer(Node)(Node node, DotIdExp exp, Scope* sc)
+        if (is(Node == Type) || is(Node == Dsymbol))
+    {
+        OutBuffer buf;
+        .mangleToBuffer(node, &buf);
+        const s = buf.peekSlice();
+        auto e = new StringExp(exp.loc, buf.extractString(), s.length);
+        return e.expressionSemantic(sc);
+    }
+
+    //printf("DotIdExp::semanticX(this = %p, '%s')\n", exp, exp.toChars());
     if (Expression ex = unaSemantic(exp, sc))
         return ex;
 
@@ -9454,7 +9464,17 @@ Expression semanticX(DotIdExp exp, Scope* sc)
             {
                 TemplateExp te = cast(TemplateExp)exp.e1;
                 ds = te.fd ? cast(Dsymbol)te.fd : te.td;
+                goto L1;
             }
+        case TOKtype:
+        {
+            auto type = (cast(TypeExp)exp.e1).type;
+
+            if (type.mangleOverride)
+                return mangleToBuffer(type, exp, sc);
+            else
+                break;
+        }
         L1:
             {
                 assert(ds);
@@ -9465,12 +9485,7 @@ Expression semanticX(DotIdExp exp, Scope* sc)
                         return new ErrorExp();
                     }
                 }
-                OutBuffer buf;
-                mangleToBuffer(ds, &buf);
-                const s = buf.peekSlice();
-                Expression e = new StringExp(exp.loc, buf.extractString(), s.length);
-                e = e.expressionSemantic(sc);
-                return e;
+                return mangleToBuffer(ds, exp, sc);
             }
         default:
             break;

src/dmd/mtype.d

@@ -513,6 +513,9 @@ extern (C++) abstract class Type : RootObject
 
     type* ctype;                    // for back end
 
+    /// Overridden symbol with `pragma(mangle, "...")`.
+    const(char)* mangleOverride;
+
     extern (C++) static __gshared Type tvoid;
     extern (C++) static __gshared Type tint8;
     extern (C++) static __gshared Type tuns8;

src/dmd/mtype.h

@@ -164,6 +164,8 @@ class Type : public RootObject
 
     type *ctype;        // for back end
 
+    const char *mangleOverride; // overridden symbol with pragma(mangle, "...")
+
     static Type *tvoid;
     static Type *tint8;
     static Type *tuns8;

test/runnable/mangle.d

@@ -589,6 +589,99 @@ void fooB(void delegate (void delegate()) scope dg)
 //pragma(msg, fooB.mangleof);
 static assert(typeof(fooA).mangleof != typeof(fooB).mangleof);
 
+/***************************************************/
+
+@("test overriding mangling for alias declaration")
+struct TestOverridingManglingAlias
+{
+    enum baseMangling = "6mangle27TestOverridingManglingAlias";
+
+    @("basic type")
+    {
+        @("override mangling")
+        {
+            pragma(mangle, "bar") alias a = int;
+            static assert(a.mangleof == "bar");
+        }
+
+        @("alias without overriding")
+        {
+            alias b = int;
+            static assert(b.mangleof == "i");
+        }
+
+        @("default mangling of basic type")
+        {
+            static assert(int.mangleof == "i");
+        }
+    }
+
+    @("struct")
+    {
+        struct Struct
+        {
+            enum defaultMangling = "S" ~ baseMangling ~"6Struct";
+        }
+
+        @("override mangling")
+        {
+            pragma(mangle, "Bar") alias c = Struct;
+            static assert(c.mangleof == "Bar");
+        }
+
+        @("alias without overriding")
+        {
+            alias d = Struct;
+            static assert(d.mangleof == Struct.defaultMangling);
+        }
+
+        @("default mangling of struct")
+        {
+            static assert(Struct.mangleof == Struct.defaultMangling);
+        }
+    }
+
+    @("class")
+    {
+        struct Class
+        {
+            enum defaultMangling = "S" ~ baseMangling ~ "5Class";
+        }
+
+        @("override mangling")
+        {
+            pragma(mangle, "Bar") alias e = Struct;
+            static assert(e.mangleof == "Bar");
+        }
+
+        @("alias without overriding")
+        {
+            alias f = Class;
+            static assert(f.mangleof == Class.defaultMangling);
+        }
+
+        @("default mangling of class")
+        {
+            static assert(Class.mangleof == Class.defaultMangling);
+        }
+    }
+
+    @("function")
+    {
+        @("type of parameter is an alias")
+        {
+            pragma(mangle, "foo") alias g = int;
+            void h(g);
+            static assert(h.mangleof == "_D" ~ baseMangling ~ "1hMFfooZv");
+        }
+
+        @("default mangling of function")
+        {
+            void i(int);
+            static assert(i.mangleof == "_D" ~ baseMangling ~ "1iMFiZv");
+        }
+    }
+}
 
 /***************************************************/