Why `foo.x.saa.aa` and `foo.y.saa.aa` is the same? `shared_AA.saa` should still be instance variable, not class variable, right?

[mw]

On Tuesday, 25 June 2024 at 02:25:14 UTC, Richard (Rikki) Andrew 
Cattermole wrote:
> On 25/06/2024 2:16 PM, mw wrote:
>> struct shared_AA {
>>    shared_AA_class saa = new shared_AA_class();  // by this 
>> syntax `saa` is still instance variable?
>>    alias saa this;
>> }
>
> When you specify an initializer like this, that instance of 
> ``shared_AA_class`` gets put into the .init of ``shared_AA``.
>

This is confusing -- well, let's try something similar in C++ and 
Java:

```
$ cat shared_aa.cpp
#include <stdio.h>

class shared_AA_class {
public:
   int aa;
   shared_AA_class() {
	  printf("new shared_AA_class\n");
   }

   void print() {
	  printf("%d\n", aa);
   }
};

struct shared_AA {
   shared_AA_class* saa = new shared_AA_class();  // by this 
syntax `saa` is still instance variable
};

class Foo {
public:
  shared_AA x;
  shared_AA y;

  Foo() {
     x.saa->aa = 1;  // only modified `x`, not `y`
  }

};

int main() {

	Foo foo;

	foo.x.saa->print();
	foo.y.saa->print();

	printf("%d\n", foo.x.saa->aa);
	printf("%d\n", foo.y.saa->aa);
}

$ g++ shared_aa.cpp
$ ./a.out
new shared_AA_class
new shared_AA_class
1
0
1
0
```

The `shared_AA_class` ctor is called twice, and `foo.x.saa` and 
`foo.y.saa` are different object.


```
$ cat Foo.java
class shared_AA_class {
  public
   int aa;
   shared_AA_class() {
	  System.out.println("new shared_AA_class");
   }

   void print() {
	  System.out.println(aa);
   }
}

class shared_AA {
   shared_AA_class saa = new shared_AA_class();  // by this syntax 
`saa` is still instance variable
}

class Foo {
	 shared_AA x;
	 shared_AA y;

	Foo() {
     x = new shared_AA();
     y = new shared_AA();
		x.saa.aa = 1;  // only modified `x`, not `y`
	}

public static void main(String[] args) {

	Foo foo = new Foo();

	foo.x.saa.print();
	foo.y.saa.print();

	System.out.println(foo.x.saa.aa);
	System.out.println(foo.y.saa.aa);
}

}

$ javac Foo.java
$ java Foo
new shared_AA_class
new shared_AA_class
1
0
1
0


```

The `shared_AA_class` ctor is called twice, and `foo.x.saa` and 
`foo.y.saa` are different object.


Why D choose to be different here? i.e. `shared_AA_class saa = 
new shared_AA_class()` only evaluate only once, and even force it 
must be evaluate-able at compile time?