inheritance.dua

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

class X
{
    int i = 3;

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

class Y : X
{
    void print() {
        printf("Y");
    }
}


// Case Basic method overriding
// Outputs "Y"

int main()
{
    Y y;
    X& x = y;
    x.print();
}


// Case Passing as a parent reference
// Outputs "Y"

void func(X& x) {
    x.print();
}

int main()
{
    Y y;
    func(y);
}


// Case Inheriting a method
// Outputs "X"

class Z : X
{

}

int main()
{
    Z z;
    z.print();
}


// Case Calling a method of a parent class
// Outputs "X"

int main()
{
    Y y;
    X::print(y);
}


// Case Inheriting from a templated class
// Outputs "i32"

class G<T>
{
    void print() {
        printf("%s", typename(T));
    }
}

class H : G<int> {}

int main()
{
    H h;
    h.print();
}


// Case Passing a template parameter as a template arg to the parent
// Outputs "i32"

class G<T>
{
    void print() {
        printf("%s", typename(T));
    }
}

class H<T> : G<T> {}

int main()
{
    H<int> h;
    h.print();
}


// Case Nesting a template parameter as a parent template arg
// Outputs "10"

class G<T>
{
    int func() { return istype(T, G<G<int>>); }
}

class H<T> : G<G<G<T>>> {}

class L<T> : G<G<G<G<G<G<G<T>>>>>>> {}

int main()
{
    H<int> h;
    L<int> l;

    printf("%d%d", h.func(), l.func());
}


// Case Specifying both a parent and a packing option
// Panics

// The packing option is inherited from the parent as well

class G packed : X { }

int main() { }


// Case Inheriting the packing option
// Outputs "13 16 18 24"

class A packed
{
    int i;
    byte c;
}

class B
{
    int i;
    byte c;
}

class C : A
{
    int ii;
    byte cc;
}

class D : B
{
    int ii;
    byte cc;
}

int main()
{
    printf("%d %d %d %d", sizeof(A), sizeof(B), sizeof(C), sizeof(D));
}


// Case Repeating a field
// Panics

class G
{
    int i;
    int i;
}

int main() { }


// Case Field with the same name as a parent field
// Panics

class G
{
    int i;
}

class H : G
{
    int i;
}

int main() { }


// Case Accessing a field of a parent
// Outputs "3"

class G
{
    int i = 3;
}

class H : G
{
    void func() {
        printf("%d", i);
    }
}

int main()
{
    H h;
    h.func();
}


// Case Accessing a templated parent field
// Outputs "i32 i64"

class G<T>
{
    T i;
}

class A : G<int>
{
    void print() {
        printf("%s ", typename(i));
    }
}

class B : G<long>
{
    void print() {
        printf("%s", typename(i));
    }
}

int main()
{
    A a;
    B b;
    a.print();
    b.print();
}


// Case Overloading a parent class method
// Outputs "03"

class G
{
    int i = 3;

    void func(int i) {
        printf("%d", (int)(self.i == i));
    }
}

class H : G
{
    void func() {
        printf("%d", i);
    }
}

int main()
{
    H h;

    h.func(4);
    h.func();
}


// Case Calling a method that accesses a field from a parent reference
// Outputs "3"

class G
{
    void func() {
        printf("0");
    }
}

class H : G
{
    int i = 3;
    void func() {
        printf("%d", i);
    }
}

int main()
{
    H h;
    G& g = h;
    g.func();
}


// Case Accepting a parameter as a parent reference
// Outputs "3"

void func(X& x) {
    printf("%d", x.i);
}

int main()
{
    Y y;
    func(y);
}


// Case Accepting a parameter as an Object reference

void func(Object& obj) {
    printf("%p", &obj);
}

int main()
{
    X x;
    func(x);
}


// Case Making an instance of the Object class

int main()
{
    Object obj;
}


// Case Having a parent pointer to an object
// Outputs "Child"


class G
{
    void func() {
        printf("Parent");
    }
}

class H : G
{
    void func() {
        printf("Child");
    }
}

int main()
{
    G* g = new H;
    g->func();
    delete g;
}


// Case Calling the right destructor
// Outputs "Child\nParent\n"

class G
{
    destructor {
        printf("Parent\n");
    }
}

class H : G
{
    destructor {
        printf("Child\n");
    }
}

int main()
{
    G* g = new H;
    delete g;
}


// Case The default calling of the super-class constructor
// Outputs "Parent\nChild\n"


class G
{
    constructor() {
        printf("Parent\n");
    }
}

class H : G
{
    constructor() {
        printf("Child\n");
    }
}

int main()
{
    H h;
}


// Case Calling an overload of the super-class constructor
// Outputs "Parent123\nChild\n"


class G
{
    constructor() {
        printf("Parent\n");
    }

    constructor(int i) {
        printf("Parent%d\n", i);
    }

    constructor(int i, int k) {
        printf("Parent%d%d\n", i, k);
    }

    constructor(int i, int k, int j) {
        printf("Parent%d%d%d\n", i, k, j);
    }
}

class H : G
{
    constructor() : Super(1, 2, 3) {
        printf("Child\n");
    }
}

int main()
{
    H h;
}


// Case Deep constructor chain
// Outputs "ABCDEFGH"

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

class B : A
{
    constructor() {
        printf("B");
    }
}

class C : B
{
    constructor() {
        printf("C");
    }
}

class D : C
{
    constructor() {
        printf("D");
    }
}

class E : D
{
    constructor() {
        printf("E");
    }
}

class F : E
{
    constructor() {
        printf("F");
    }
}

class G : F
{
    constructor() {
        printf("G");
    }
}

class H : G
{
    constructor() {
        printf("H");
    }
}

int main()
{
    H h;
}


// Case Initializing fields in current-class and super-class constructors
// Outputs "12345"

class G
{
    int a;
    int b;

    constructor(int a, int b) : a(a), b(b) {}
}

class H : G
{
    int c;
    long d;
    int e;

    constructor(int a, int b, int c, int d, int e) : Super(a, b), c(c), d(d), e(e) {}

    void print() {
        printf("%d%d%d%d%d", a, b, c, d, e);
    }
}

int main()
{
    H h(1, 2, 3, 4, 5);
    h.print();
}


// Case Overwriting the super-class initialization
// Outputs "1233345"

class G
{
    int a;
    int b;

    constructor(int a, int b) : a(1), b(2) {
        printf("%d%d", self.a, self.b);
    }
}

class H : G
{
    int c;
    long d;
    int e;

    constructor(int a, int b, int c, int d, int e) : a(3), b(3), Super(a, b), c(c), d(d), e(e) {}

    void print() {
        printf("%d%d%d%d%d", a, b, c, d, e);
    }
}

int main()
{
    H h(1, 2, 3, 4, 5);
    h.print();
}


// Case Inheriting from the template parameter
// Outputs "H"

class G<T> : T
{
}

class H
{
    void print() { printf("H\n"); }
}

int main()
{
    G<H> g;
    g.print();
}


// Case Dynamic dispatch with templated parent
// Outputs "H\n"

class G<T>
{
    void print() { printf("G\n"); }
}

class H : G<int>
{
    void print() { printf("H\n"); }
}

int main()
{
    G<int>* g = new H;
    g->print();
    delete g;
}


// Case Constructor call chain with templated parent
// Outputs "H\nG\nL\n3"

class G<T> : T
{
    constructor(int i) : Super(i) {
        printf("G\n");
    }
}

class H
{
    int i;
    constructor(int i) : i(i) {
        printf("H\n");
    }
}

class L : G<H>
{
    constructor(int i) : Super(i) {
        printf("L\n");
    }
}

int main()
{
    L l(3);
    printf("%d", l.i);
}