Fix issue 18716: type const(char)[] can not be mapped to C++

D arrays don't have any corresponding type in C++. Instead we mangle
it as a templated struct with the name `__dslice`, i.e.
`struct __dslice(T)`, where `T` is the element type of the array. For
an array of ints it would be mangled as the following type:
`__dslice!int`.

Author: jacob-carlborg

changelog/dslices-cpp-mangling.dd

@@ -0,0 +1,57 @@
+Added support for D arrays in C++ functions
+
+D arrays don't have any corresponding type in C++. This change adds support for
+mangling a D array as a templated struct with the special name: `__dslice`.
+Under the hood, a D array is represented as a struct, containing the length of
+the array and a pointer to the data:
+
+---
+struct DArray(T)
+{
+    size_t length;
+    T* ptr;
+}
+---
+
+Any D array in the form of, `T[]`, when used in a C++ function, will be mangled
+as the following struct:
+
+---
+struct __dslice(T);
+---
+
+For example, an array of ints, `int[]`, will be mangled as `__dslice!int` when
+used in a C++ function. This allows to declare C++ functions that accepts D
+arrays and can be accessed to C++ if the right struct declaration is present
+on the C++ side.
+
+On the D side:
+
+---
+extern(C++) void foo(const(char)[] str);
+
+void main()
+{
+    foo("bar");
+}
+---
+
+On the C++ side:
+
+$(CPPCODE
+    #include <stdio.h>
+
+    template<typename T> struct __dslice
+    {
+        size_t length;
+        T* ptr;
+    };
+
+    void foo(__dslice<const char> array)
+    {
+        printf("%.*s\n", (int) array.length, array.ptr);
+    }
+)
+
+Since the `__dslice` struct is ABI compatible with D arrays, it works perfectly
+fine to pass a D array to a C++ function taking a `__dslice`.

src/dmd/cppmangle.d

@@ -735,7 +735,12 @@ public:
 
     override void visit(Type t)
     {
-        error(t);
+        auto typeForMangling = t.typeForMangling(LINK.cpp);
+
+        if (typeForMangling is t)
+            error(t);
+        else
+            typeForMangling.accept(this);
     }
 
     /******

src/dmd/dmangle.d

@@ -1118,6 +1118,11 @@ extern (C++) const(char)* mangleExact(FuncDeclaration fd)
 
 extern (C++) void mangleToBuffer(Type t, OutBuffer* buf)
 {
+    auto typeForMangling = t.typeForMangling(LINK.d);
+
+    if (t !is typeForMangling)
+        return mangleToBuffer(typeForMangling, buf);
+
     if (t.deco)
         buf.writestring(t.deco);
     else

src/dmd/id.d

@@ -407,6 +407,7 @@ immutable Msgtable[] msgtable =
     { "basic_ostream" },
     { "basic_iostream" },
     { "char_traits" },
+    { "__dslice" },
 
     // Compiler recognized UDA's
     { "udaSelector", "selector" },

src/dmd/mtype.d

@@ -565,6 +565,24 @@ extern (C++) abstract class Type : RootObject
         return DYNCAST.type;
     }
 
+    /**
+     * Returns the type the receiver should be treated as during mangling.
+     *
+     * This allows for a type to be treated as a different type during mangling.
+     * This is useful, for example, when interfacing with C++, for D types that
+     * don't have a corresponding C++ type. This can allow `int[]` to be
+     * mangled as `__dslice!int` during C++ mangling.
+     *
+     * Params:
+     *  linkage = the type of mangling that is requested
+     *
+     * Returns: the type the receiver should be treated as during mangling
+     */
+    Type typeForMangling(LINK linkage) pure nothrow
+    {
+        return this;
+    }
+
     /*******************************
      * Covariant means that 'this' can substitute for 't',
      * i.e. a pure function is a match for an impure type.
@@ -3846,6 +3864,9 @@ extern (C++) final class TypeSArray : TypeArray
  */
 extern (C++) final class TypeDArray : TypeArray
 {
+    /// Mangle D array as this type when mangling for C++.
+    package Type typeForCppMangling;
+
     extern (D) this(Type t)
     {
         super(Tarray, t);
@@ -3870,6 +3891,11 @@ extern (C++) final class TypeDArray : TypeArray
         return t;
     }
 
+    override Type typeForMangling (LINK linkage) pure nothrow
+    {
+        return linkage == LINK.cpp ? typeForCppMangling : this;
+    }
+
     override d_uns64 size(const ref Loc loc) const
     {
         //printf("TypeDArray::size()\n");

src/dmd/mtype.h

@@ -236,6 +236,7 @@ class Type : public RootObject
     bool equivalent(Type *t);
     // kludge for template.isType()
     int dyncast() const { return DYNCAST_TYPE; }
+    virtual Type* typeForMangling(LINK linkage) /*pure nothrow*/;
     int covariant(Type *t, StorageClass *pstc = NULL, bool fix17349 = true);
     const char *toChars();
     char *toPrettyChars(bool QualifyTypes = false);
@@ -459,9 +460,14 @@ class TypeSArray : public TypeArray
 // Dynamic array, no dimension
 class TypeDArray : public TypeArray
 {
+private:
+    Type* typeForCppMangling;
+
 public:
+
     const char *kind();
     Type *syntaxCopy();
+    Type* typeForMangling(LINK linkage) /*pure nothrow*/;
     d_uns64 size(const Loc &loc) /*const*/;
     unsigned alignsize() /*const*/;
     bool isString();

src/dmd/root/array.d

@@ -29,6 +29,21 @@ private:
 public:
     @disable this(this);
 
+    /**
+     * Connivence constructor to add the given elements to this array.
+     *
+     * Params:
+     *  elements = elements to add to this array
+     */
+    extern(D) this(T[] elements ...) nothrow
+    {
+        if (elements.length > 0)
+            reserve(elements.length);
+
+        foreach (e ; elements)
+            push(e);
+    }
+
     ~this() nothrow
     {
         if (data != &smallarray[0])

src/dmd/root/array.h

@@ -240,4 +240,17 @@ struct BitArray
     BitArray(const BitArray&);
 };
 
+// This is the type that the D compiler will mangle D slices as when mangling
+// for C++. This type is ABI compatible with native D slices.
+template <typename T> struct __dslice
+{
+    d_size_t length;
+    T* ptr;
+
+    __dslice() : length(0), ptr(NULL) {}
+    __dslice(size_t length, T* ptr) : length(length), ptr(ptr) {}
+};
+
+#define DSlice __dslice
+
 #endif

src/dmd/typesem.d

@@ -497,6 +497,83 @@ private extern (C++) final class TypeSemanticVisitor : Visitor
 
     override void visit(TypeDArray mtype)
     {
+        /**
+         * Returns a template declaration corresponding to the following code:
+         *
+         * ---
+         * template __dslice(T) {}
+         * ---
+         *
+         * Returns: a template declaration corresponding to the above code
+         *
+         * See_Also: `typeForCppMangling`
+         */
+        TemplateDeclaration dsliceTemplateDeclaration()
+        {
+            __gshared TemplateDeclaration td;
+
+            if (td)
+                return td;
+
+            auto ttp = new TemplateTypeParameter(loc, Id.p, null, null);
+            auto parameters = new TemplateParameters(ttp);
+
+            return td = new TemplateDeclaration(loc, Id.__dslice, parameters,
+                null, null);
+        }
+
+        /**
+         * Returns a template instantiation of the template declaration returned
+         * by `dsliceTemplateDeclaration`.
+         *
+         * The template is instantiated with the element type of this array. For
+         * an array of ints it would correspond to the following D code:
+         * `__dslice!int`.
+         *
+         * Returns: a template instance
+         *
+         * See_Also: `dsliceTemplateDeclaration`
+         * See_Also: `typeForCppMangling`
+         */
+        TemplateInstance dsliceTemplateInstance()
+        {
+            auto tiargs = new Objects(mtype.next);
+            auto ti = new TemplateInstance(loc, Id.__dslice, tiargs);
+            ti.tempdecl = dsliceTemplateDeclaration();
+
+            return ti;
+        }
+
+        /**
+         * Returns the type that this array type should be treated as when it's
+         * mangled as a C++ type.
+         *
+         * D arrays don't have any corresponding type in C++. Instead we mangle
+         * it as a templated struct with the name `__dslice`, i.e.
+         * `struct __dslice(T)`, where `T` is the element type of the array. For
+         * an array of ints it would be mangled as the following type
+         * `__dslice!int`.
+         *
+         * Returns: the type that this should be treated as when mangling as a
+         *  C++ type
+         *
+         * See_Also: `dsliceTemplateInstance`
+         */
+        Type typeForCppMangling()
+        {
+            __gshared Type[char*] cachedTypes;
+            auto elementType = mtype.next;
+
+            if (auto type = elementType.deco in cachedTypes)
+                return *type;
+
+            auto sd = new StructDeclaration(loc, Id.__dslice, false);
+            sd.parent = dsliceTemplateInstance();
+
+            auto type = new TypeStruct(sd).typeSemantic(loc, sc);
+            return cachedTypes[elementType.deco] = type;
+        }
+
         Type tn = mtype.next.typeSemantic(loc, sc);
         Type tbn = tn.toBasetype();
         switch (tbn.ty)
@@ -523,6 +600,8 @@ private extern (C++) final class TypeSemanticVisitor : Visitor
         }
         mtype.next = tn;
         mtype.transitive();
+        mtype.typeForCppMangling = typeForCppMangling();
+
         result = merge(mtype);
     }
 

test/compilable/cppmangle.d

@@ -450,3 +450,28 @@ version (Posix) // all non-Windows machines
     static assert(test37!int.mangleof == "_ZN5SPACE6test37IiEEiv");
 }
 
+/*****************************************/
+// https://issues.dlang.org/show_bug.cgi?id=18716
+
+struct Test18716 {}
+struct __dslice(T) {}
+
+extern(C++) void test18716a(char[]);
+extern(C++) void test18716b(__dslice!char);
+extern(C++) void test18716c(const(char)[]);
+extern(C++) void test18716d(Test18716[]);
+
+void test18716()
+{
+    test18716a("foo".dup);
+    test18716c("foo");
+    test18716d([Test18716()]);
+}
+
+version (Posix)
+{
+    static assert(test18716a.mangleof == "_Z10test18716a8__dsliceIcE");
+    static assert(test18716b.mangleof == "_Z10test18716b8__dsliceIcE");
+    static assert(test18716c.mangleof == "_Z10test18716c8__dsliceIKcE");
+    static assert(test18716d.mangleof == "_Z10test18716d8__dsliceI9Test18716E");
+}