On Saturday, 4 November 2023 at 12:34:28 UTC, Dadoum wrote:

There is a syntax disagreement here that's why the D compiler is instantly stopping you from doing any symbol generated interaction with string in C++ interop. C++ doesn't know 'string' and C++ mangles with parameters and so passing string will make string get involved with the symbol generation and since string(std::string) in C++ is a template library, the D compiler stops you from engaging with 'string'

On Saturday, 4 November 2023 at 13:45:56 UTC, Emmanuel Danso Nyarko wrote:

I don't think it's related to the existence of std::string at all since all dynamic array types are forbidden.

extern (C++) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

also fails to compile while this works:

extern (C) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

On Saturday, 4 November 2023 at 03:00:49 UTC, Dadoum wrote:

extern(C++) functions use C++ name mangling, which includes the types of the parameters in the mangled name. However, since C++ does not have a built-in slice type like D's T[], there is no valid C++ mangling for a D slice. Because of this, it is impossible to compile an extern(C++) function that has a D slice as a parameter.

As a workaround, you can convert the slice to a struct:

struct DSlice(T)
{
    T* ptr;
    size_t length;

    T[] opIndex() => ptr[0 .. length];
}

DSlice!T toDslice(T)(T[] slice)
{
	return DSlice!T(slice.ptr, slice.length);
}

extern(C++) void hello(DSlice!(const(char)) arg)
{
    import std.stdio;
    writeln(arg[]);
}

void main()
{
	const(char)[] greeting = "hello";
	hello(greeting.toDslice);
}

On Saturday, 4 November 2023 at 13:51:20 UTC, Dadoum wrote:

extern (C++) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

extern (C) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

Here too you will get the same error, cannot be mapped to C++. C++ mangles dynamic arrays as pointer arrays(uses the 'P' symbol), which is supported by D for interfacing with C. Another disagreement here using it in c++ interop. Hence will not compile. Once again, I think the compiler team will be the best to give you what you're looking for.

On Saturday, 4 November 2023 at 14:21:49 UTC, Paul Backus wrote:

I use another workaround myself:

extern (C++) struct List(T) { // or extern (C)
        T[] self;
        alias self this;
}

extern (C++) void hello(List!ubyte arg) {
        import std.stdio;
        writeln(arg);
}

but it means adding a lot of edge cases to the mixins I use for bindings while showing that C++ can express D arrays.

(translated to

template <typename T>
struct List final
{
    _d_dynamicArray< T > self;
    List()
    {
    }
};

extern void hello(List<uint8_t > arg);

)

On Saturday, 4 November 2023 at 13:51:20 UTC, Dadoum wrote:

extern (C++) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

extern (C) void hello(ubyte[] arg) {
        import std.stdio;
        writeln(arg);
}

The type simply cannot be mangled using the C++ mangler as it does not exist over there. You might have the impression that this should be allowed, e.g as an extension, but keep in mind that extern(C++) is firstly designed to link against object produced by a C++ compiler.

Now why this works in extern(C) ? Because C does not mangle the parameters, a function linkage name is simply its unqualified name, so linking will work even if the parameter types are specific to D.

Now there is still the question whether the extern(C) code will work as expected or not.

On Saturday, 4 November 2023 at 14:33:56 UTC, Basile B. wrote:

Could the mangling be provided with pragma and made to work?

On Saturday, 4 November 2023 at 14:21:49 UTC, Paul Backus wrote:

Simply add perfectly explained!

On Saturday, 4 November 2023 at 14:33:56 UTC, Basile B. wrote:

So with few patches could we make it work? DMD can write the C++ function prototype (as it does it with extern (C)) and then mangle it as the template it uses in C?