Consider the following code:

class Foo {  }

class Bar { Foo foo = new Foo(); }

void main()
{
	Bar b1 = new Bar();
	Bar b2 = new Bar();

	assert(b1.foo != b2.foo);
}

The assert fails. This is completely surprising to me. Is this actually expected?

On Wednesday, 9 June 2021 at 17:56:24 UTC, Gregor Mückl wrote:

This is a static initialization....

Yes, it is expected if you are familiar with the spec.

All member = x things inside a class or struct declaration are static initializers. These are CTFE'd into the same form as a literal. So there's one instance of Foo there which is assigned to the object member before the constructor runs.

For a runtime initialization, you use a constructor.

On Wednesday, 9 June 2021 at 17:56:24 UTC, Gregor Mückl wrote:

class Foo {  }

class Bar { Foo foo = new Foo(); }

void main()
{
	Bar b1 = new Bar();
	Bar b2 = new Bar();

	assert(b1.foo != b2.foo);
}

By design.
What you see is CTFE instance shared through class member initializer.

Use Bar ctor instead if you want them to be unique.

Yep, confusing for the first time.

On Wednesday, 9 June 2021 at 18:04:54 UTC, evilrat wrote:

class Foo {  }

class Bar { Foo foo = new Foo(); }

void main()
{
	Bar b1 = new Bar();
	Bar b2 = new Bar();

	assert(b1.foo != b2.foo);
}

My two cents:

I think this should be changed because all other common languages that support equivalent syntax have settled on runtime initialization for this. But it's probably too deeply embedded into the language now. :(

On Wednesday, 9 June 2021 at 18:12:01 UTC, Gregor Mückl wrote:

class Foo {  }

class Bar { Foo foo = new Foo(); }

void main()
{
	Bar b1 = new Bar();
	Bar b2 = new Bar();

	assert(b1.foo != b2.foo);
}

Can we add (enforcement) static in this case, to make it clear. It's so confusing.