I'd like to understand how any D type is represented as a string by the name mangling done by the compilers.

Does this always have the desirable property that different types have different mangled names, so that a type is faithfully represented by its mangled string incorporated into a symbol name in an object file?

What is that representation of a type as a string, and how does it work for recursive types like a struct containing a pointer to a struct of the same type?

Please explain.

On Tuesday, 3 August 2021 at 16:43:52 UTC, NonNull wrote:

Name mangling applies to function parameters, as described here:

https://forum.dlang.org/thread/akshntlfahjpknsxdrdv@forum.dlang.org

Type names aren't mangled. They have a Fully Qualified Name (FQN) which is constructed from package(s), module, parent.

So for example:

module mypack.mymod;

import std.stdio;

struct S
{
    struct Is {}
}

void main()
{
    writeln(typeid(S));
    writeln(typeid(S.Is));
}

This prints:

mypack.mymod.S
mypack.mymod.S.Is

On Tuesday, 3 August 2021 at 16:43:52 UTC, NonNull wrote:

A struct S with a member of type S* is still just a struct S. The pointer doesn't change anything about the type.

On Tuesday, 3 August 2021 at 17:01:38 UTC, Mike Parker wrote:

Aha, so it just uses the name S, not an algebraic representation of the structure of S.

On Tuesday, 3 August 2021 at 20:29:10 UTC, NonNull wrote:

Yes, because D is a nominal type system, using the FQN of the symbol is enough.

Mangled names start with _D and then contain the encoding of the symbol being mangled (can be a variable, a function, etc...).

To avoid an explosion in the symbol length we have back reference (which the blog mentions IIRC). Not only are parameter types encoded, but so are function attributes (@safe and co), with the notable exception of inferred scope, to allow people to link -dip1000 code with non-DIP1000 code.

core.demangle provides a programmatic way to demangle a symbol to its code representation. ddemangle, packed with DMD, allow to do it via the CLI (similar to c++filt). Newer binutils have support for D as well, so nm --demangle=dlang works (note that some older binutils support this, but don't support backref).

Mangling is altered by extern(LANG) (where LANG is one of C, C++, Objective-C, System, D), or pragma(mangle).

On Wednesday, 4 August 2021 at 02:01:54 UTC, Mathias LANG wrote:

All useful information, thank you.