/+ dub.json:
{
  "name": "test",
  "dependencies": {
  }
}
+/

struct S
{
    ~this() {}
}

immutable class Imm
{
    S s; // this is immutable value because whole class is immutable

    this()
    {
        s = S();
    }

    ~this() {} // Comment out this to fix this compilation  error:
    // Error: `immutable` method `serializer_bug.Imm.~this` is not callable using a mutable object
    // What mutable object is meant here?
}


void main()
{
    auto ic = new immutable Imm();
}

Run: $ dub --single bug.d

On Friday, 17 December 2021 at 17:27:53 UTC, Denis Feklushkin wrote:

~this() {} // Comment out this to fix this compilation  error:
// Error: `immutable` method `serializer_bug.Imm.~this` is

("serializer_bug" is just name of my local .d file)

On Friday, 17 December 2021 at 17:34:05 UTC, Denis Feklushkin wrote:

~this() {} // Comment out this to fix this compilation  error:
// Error: `immutable` method `serializer_bug.Imm.~this` is

I think since immutable objects are kept in Read Only Storage, you can't call destructors on them since the objects don't get erased when ~this is called, but rather they get assigned their .init value, which tells the GC that they can be collected.

immutable class has nothing to do with it, even the following fails to compile:

struct S
{
    ~this() immutable {}
}

void main()
{
    S s = S();
}

Error: `immutable` method `onlineapp.S.~this` is not callable using a mutable object

On Friday, 17 December 2021 at 18:01:03 UTC, Tejas wrote:

[...]

struct S
{
    ~this() immutable {}
}

void main()
{
    S s = S();
}

Error: `immutable` method `onlineapp.S.~this` is not callable using a mutable object

Correction:
immutable S s = S(); inside the void main()

On Friday, 17 December 2021 at 18:01:03 UTC, Tejas wrote:

Some of them can be stored in ROM in some cases, but actually "immutable" keyword means "not mutable for whole its lifetime"

On Friday, 17 December 2021 at 18:02:52 UTC, Tejas wrote:

I improved your sample:

immutable struct S
{
    ~this() {}
}

immutable struct S2
{
    S sss;
    ~this() {}
}

void main()
{
    S2 s = S2();
}

Error: `immutable` method `serializer_bug.S.~this` is not callable using a mutable object
Error: mutable method `serializer_bug.S2.~this` is not callable using a `immutable` object
serializer_bug.d(17,5):        Consider adding `const` or `inout` here

immutable dtor can't be called at all?

On Friday, 17 December 2021 at 18:19:34 UTC, Denis Feklushkin wrote:

Well, it would be really weird if destructors successfully executed for some class of immutable qualified objects but didn't for others.

Not too much of a stretch to imagine that destruction for immutable objects was outright disallowed.

Someone who can explain this behaviour more thoroughly would be much appreciated 😊

Maybe we should allow finalizers to mutate their instance?

On Friday, 17 December 2021 at 18:32:43 UTC, Denis Feklushkin wrote:

immutable struct S
{
    ~this() {}
}

immutable struct S2
{
    S sss;
    ~this() {}
}

void main()
{
    S2 s = S2();
}

Error: `immutable` method `serializer_bug.S.~this` is not callable using a mutable object
Error: mutable method `serializer_bug.S2.~this` is not callable using a `immutable` object
serializer_bug.d(17,5):        Consider adding `const` or `inout` here

Nope, seems to go against the very promise it's making

Labelling ~this() as const or immutable means it won't affect the state of the object, but it will, by it's very nature.

That's why I said it's not too much of a stretch to imagine why they're disallowed entirely.

On Friday, 17 December 2021 at 18:51:56 UTC, Ali Çehreli wrote:

Well, I got completely mislead by my experiment 😓

struct S
{
    ~this() immutable {}
}

void main()
{
    immutable S s = S();
}

This failed, so I just came up with reasons to justify this behaviour

Thanks for correcting me 😃