class-construction.dua

nomangle int printf(str message, ...);

void print(int num) { printf("%d", num); }

// Case Initializing a reference type in the constructor
// Outputs "3"

class X
{
    int& num;

    constructor(int& num) : num(num) {}
}

int main()
{
    int n = 2;
    X x(n);
    n = 3;
    printf("%d", x.num);
}


// Case Initializing a reference type in by assigning
// Outputs "4"

int i = 3;

class X
{
    int& num = i;
}

int main()
{
    X x;
    i = 4;
    printf("%d", x.num);
}


// Case Initializing a reference type by default constructor args
// Outputs "4"

int i = 3;

class X
{
    int& num(i);
}

int main()
{
    X x;
    i = 4;
    printf("%d", x.num);
}


// Case Passing a reference field around
// Outputs "123"

class X
{
    int& x;

    constructor(int& x) : x(x) { }

    void func() {
        x = 2;
    }
}

void func(int& value) {
    value = 3;
}

int main()
{
    int num = 1;
    print(num);
    X x(num);
    x.func();
    print(num);
    func(num);
    print(num);
}


// Case Accessing a reference field through self
// Outputs "4"

class X
{
    int& num;

    constructor(int& num) : num(num) { }

    void func() {
        self.num = 4;
    }
}

int main()
{
    int n = 1;
    X x(n);
    x.func();
    print(n);
}


// Case Constructor with parameters call
// Outputs "a1b2c3Aa4b4c4Ba9b8c7CD"

class X
{
    constructor(int a, int b, int c)
    {
        printf("a%db%dc%d", a, b, c);
    }
}

class Y
{
    // No constructor is defined
}

X x(1, 2, 3);

int main()
{
    printf("A");
    X x1(4, 4, 4);
    printf("B");
    X x2(9, 8, 7);
    printf("C");
    Y y;
    printf("D");
}


// Case Destructor call
// Outputs "5X"

class X
{
    int x = 3;
    constructor()
    {
        self.x = 5;
    }

    destructor
    {
        printf("X");
    }
}

class Y
{
    int z;
    constructor(int a, int b) { }

    // No destructor is defined
}

int main()
{
    X x;
    print(x.x);
    Y y(3, 4);
}


// Case Nested constructor calls
// Outputs "562567"

class X
{
    Y y;

    constructor(int i, int j) : y()
    {
        print(i);
        print(j);
    }

}

class Y
{
    constructor()
    {
        print(5);
    }
}

class Z
{
    X x;
    Y y;

    constructor(int i, int j) : x(i, 2), y()
    {
        print(i);
        print(j);
    }
}

int main()
{
    Z z(6, 7);
}


// Case Nested destructor calls
// Outputs "211321211"

class X
{
    Y y;

    destructor
    {
        print(3);
    }
}

class Y
{
    Z z;

    destructor
    {
        print(2);
    }
}

class Z
{
    destructor
    {
        print(1);
    }
}

int main()
{
    { { Y y; } { Z z; } }

    { X x; }
    { Y y; }
    { Z z; }
}


// Case Constructor with primitive types
// Outputs "12"

class X
{
    int i;
    int j;

    constructor(int _i, int _j) : i(_i), j(_j) {}
}

int main()
{
    X x(1, 2);
    print(x.i);
    print(x.j);
}


// Case Initializing a member class with a default value
// Outputs "123"

class X
{
    Y y(1, 2, 3);
}

class Y
{
    constructor(int i, int j, int k)
    {
        print(i);
        print(j);
        print(k);
    }
}

int main()
{
    X x;
}


// Case Initializing a member class, both with a default value, and in the constructor
// Outputs "343"

class X
{
    int x = 3;
    Y y(1, 2);

    constructor() : y(3, 4) { }
}

class Y
{
    constructor(int i, int j) { print(i); print(j); }
}

int main()
{
    X x;
    print(x.x);
}


// Case Order of construction
// Outputs "123"

class X
{
    A a;
    B b;
    C c;
}

class A
{
    constructor() { print(1); }
}

class B
{
    constructor() { print(2); }
}

class C
{
    constructor() { print(3); }
}

int main()
{
    X x;
}


// Case Order of destruction
// Outputs "321"

class X
{
    A a;
    B b;
    C c;
}

class A
{
    destructor { print(1); }
}

class B
{
    destructor { print(2); }
}

class C
{
    destructor { print(3); }
}

int main()
{
    X x;
}


// Case Construction order with inheritance
// Outputs "X1X1X2X1X1X2X3"

class X1
{
    constructor() { printf("X1"); }
}

class X2 : X1
{
    X1 x1;
    constructor() { printf("X2"); }
}

class X3 : X2
{
    // x1 is inherited
    X2 x2;
    constructor() { printf("X3"); }
}

int main()
{
    // Order:
    //  1 - Constructor of the deepest ancestor of X3 (X1)
    //  2 - Constructor of the field X2::x1 (X1)
    //  3 - Constructor of parent of X3 (X2)
    //  4 - Constructor of the field x1 of the X3::x2 field (X1)
    //  5 - Constructor of the parent of X3::x2 field (X1)
    //  6 - Constructor of the field x2 in X3 (X2)
    //  7 - Constructor of X3 (X3)
    X3 x;
}


// Case Destruction order with inheritance
// Outputs "X3X2X1X1X2X1X1"

class X1
{
    destructor { printf("X1"); }
}

class X2 : X1
{
    X1 x1;
    destructor { printf("X2"); }
}

class X3 : X2
{
    // x1 is inherited
    X2 x2;
    destructor { printf("X3"); }
}

int main()
{
    // Order:
    //  1 - Destructor of X3 (X3)
    //  2 - Destructor of the field x2 in X3 (X2)
    //  3 - Destructor of the field x1 of the X3::x2 field (X1)
    //  4 - Destructor of the parent of X3::x2 field (X1)
    //  5 - Destructor of parent of X3 (X2)
    //  6 - Destructor of the field X2::x1 (X1)
    //  7 - Destructor of the deepest ancestor of X3 (X1)
    X3 x;
}


// Case Moving of the result of a block expression
// Outputs "21X3"

class X
{
    int i;

    constructor(int i) : i(i) { }

    constructor(X& x) { printf("C"); }

    destructor { printf("%d", i); }
}

int main()
{
    var x = {
        X x1(1);
        X x2(2);
        X x3(3);
        move(x3)
    };

    printf("X");
}


// Case Teleportation of the result of an if expression
// Outputs "21X3"

class X
{
    int i;

    constructor(int i) : i(i) { }

    destructor { printf("%d", i); }
}

int main()
{
    var x = if (true) {
        X x1(1);
        X x2(2);
        X x3(3);
        move(x3)
    } else {
        X x2(2);
        move(x2)
    };

    printf("X");
}


// Case Teleportation of the result of a when expression
// Outputs "21X3"

class X
{
    int i;

    constructor(int i) : i(i) { }

    destructor { printf("%d", i); }
}

int main()
{
    var x = when {
        true -> {
            X x1(1);
            X x2(2);
            X x3(3);
            move(x3)
        },
        else -> {
            X x2(2);
            move(x2)
        }
    };

    printf("X");
}


// Case Using the returned object in the destructor of a local object
// Outputs "Hello"

class X
{
    X* x;

    void print() { printf("Hello"); }

    destructor {
        if (x != null)
            x->print();
    }
}

X func()
{
    X x1;
    X x2;

    x1.x = &x2;

    return x2;
}

int main()
{
    func();
}


// Case Copying a child class with no copy-constructor
// Outputs "Parent2"

class Parent
{
    int i = 3;

    void print() {
        printf("Parent");
    }
}

class Child : Parent
{
    int j = 5;

    void print() {
        printf("Child");
    }
}

int main()
{
    Child c;
    c.i = 2;
    Parent p = *((Parent*))&c;
    p.print();
    printf("%d", p.i);
}


// Case Construction of global objects
// Outputs "Hello 5"

class X
{
    constructor(int i) {
        printf("Hello %d", i);
    }
}

X x(5);

int main()
{

}


// Case Destruction of global objects
// Outputs "Bye"

class X
{
    destructor {
        printf("Bye");
    }
}

X x;

int main()
{

}


// Case Assigning an object with no infix = defined
// Outputs "XYZ"

class X
{
    =constructor(X& x) { printf("X"); }
}

class Y
{
    =constructor(Y& y) { printf("Y"); }
}

class Z
{
    =constructor(Z& z) { printf("Z"); }
}

class G
{
    X x;
    Y y;
    Z z;
}

int main()
{
    G g1;
    G g2;
    g2 = g1;
}


// Case Implicit return of an object
// Outputs "CD"

class X
{
    constructor() { printf("C"); }
    destructor    { printf("D"); }
}

X func() {
    // No return statement. An implicit return
    // with the default value will be returned,
    // and a warning will be reported
}

int main()
{
    var x = func();
}