//! Test trait methods returning aggregate types.

//!

//! Exercises: trait methods that return structs (both small and larger

//! than pointer size) and optionals via v-table dispatch.

record Point {

    x: i32,

    y: i32,

}

record Vec3 {

    x: i32,

    y: i32,

    z: i32,

}

trait Geometry {

    fn (*Geometry) origin() -> Point;

    fn (*Geometry) center() -> Vec3;

    fn (*Geometry) maybe() -> ?i32;

}

record Circle {

    cx: i32,

    cy: i32,

    radius: i32,

}

instance Geometry for Circle {

    fn (c: *Circle) origin() -> Point {

        return Point { x: c.cx, y: c.cy };

    }

    fn (c: *Circle) center() -> Vec3 {

        return Vec3 { x: c.cx, y: c.cy, z: 0 };

    }

    fn (c: *Circle) maybe() -> ?i32 {

        if c.radius > 0 {

            return c.radius;

        }

        return nil;

    }

}

@default fn main() -> i32 {

    let c = Circle { cx: 10, cy: 20, radius: 5 };

    let g: *opaque Geometry = &c;

    // Small struct return (Point, 8 bytes = pointer size).

    let p = g.origin();

    if p.x != 10 {

        return 1;

    }

    if p.y != 20 {

        return 2;

    }

    // Larger struct return (Vec3, 12 bytes > pointer size).

    let v = g.center();

    if v.x != 10 {

        return 3;

    }

    if v.y != 20 {

        return 4;

    }

    if v.z != 0 {

        return 5;

    }

    // Optional return - Some case.

    let m = g.maybe();

    if let val = m {

        if val != 5 {

            return 6;

        }

    } else {

        return 7;

    }

    // Optional return - None case.

    let c2 = Circle { cx: 0, cy: 0, radius: 0 };

    let g2: *opaque Geometry = &c2;

    let m2 = g2.maybe();

    if let _ = m2 {

        return 8;

    }

    return 0;

}

//! Test trait objects stored in arrays and used as optional values.

//!

//! Exercises: arrays of trait objects dispatched in loops,

//! and optional trait object values.

record Adder {

    n: i32,

}

record Multiplier {

    n: i32,

}

trait Transform {

    fn (*Transform) apply(x: i32) -> i32;

}

instance Transform for Adder {

    fn (a: *Adder) apply(x: i32) -> i32 {

        return x + a.n;

    }

}

instance Transform for Multiplier {

    fn (m: *Multiplier) apply(x: i32) -> i32 {

        return x * m.n;

    }

}

/// Apply a chain of transforms to a value.

fn applyAll(transforms: *[*opaque Transform], value: i32) -> i32 {

    let mut result = value;

    for i in 0..transforms.len {

        result = transforms[i].apply(result);

    }

    return result;

}

/// Apply an optional transform, returning the original value if nil.

fn applyMaybe(t: ?*opaque Transform, value: i32) -> i32 {

    if let tr = t {

        return tr.apply(value);

    }

    return value;

}

@default fn main() -> i32 {

    let a1 = Adder { n: 10 };

    let m1 = Multiplier { n: 3 };

    let a2 = Adder { n: 5 };

    let t1: *opaque Transform = &a1;

    let t2: *opaque Transform = &m1;

    let t3: *opaque Transform = &a2;

    // Array of trait objects.

    let transforms: [*opaque Transform; 3] = [t1, t2, t3];

    // Chain: (1 + 10) * 3 + 5 = 38

    let result = applyAll(&transforms[..], 1);

    if result != 38 {

        return 1;

    }

    // Optional trait object - Some case.

    let opt: ?*opaque Transform = t1;

    let r2 = applyMaybe(opt, 5);

    if r2 != 15 {

        return 2;

    }

    // Optional trait object - None case.

    let none: ?*opaque Transform = nil;

    let r3 = applyMaybe(none, 5);

    if r3 != 5 {

        return 3;

    }

    return 0;

}

//! Test trait methods with throws clauses.

union ParseError {

    InvalidInput,

    Overflow,

}

record StrictParser {

    limit: i32,

}

trait Parser {

    fn (*Parser) parse(n: i32) -> i32 throws (ParseError);

}

instance Parser for StrictParser {

    fn (p: *StrictParser) parse(n: i32) -> i32 throws (ParseError) {

        if n < 0 {

            throw ParseError::InvalidInput;

        }

        if n > p.limit {

            throw ParseError::Overflow;

        }

        return n * 2;

    }

}

@default fn main() -> i32 {

    let sp = StrictParser { limit: 100 };

    let p: *opaque Parser = &sp;

    // Success path.

    let r1 = try p.parse(5) catch {

        return 1;

    };

    if r1 != 10 {

        return 2;

    }

    // Error path: negative input.

    let mut caught = false;

    let r2 = try p.parse(-1) catch {

        caught = true;

        0

    };

    if not caught {

        return 3;

    }

    // Error path: overflow.

    caught = false;

    let r3 = try p.parse(200) catch {

        caught = true;

        0

    };

    if not caught {

        return 4;

    }

    return 0;

}

    // Check for trait method dispatch.

    let mut resVal: il::Val = undefined;

    if let case resolver::NodeExtra::TraitMethodCall {

        traitInfo, methodIndex

    } = resolver::nodeData(self.low.resolver, t.expr).extra {

        resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);

    } else {

        resVal = try lowerCall(self, t.expr, callExpr);

    }

    // Data pointer is the receiver (first argument after hidden return param).

    // Allocate the return buffer when needed.

    if returnParam {

        if methodFnType.throwListLen > 0 {

            let successType = *methodFnType.returnType;

            let layout = resolver::getResultLayout(

                successType, &methodFnType.throwList[..methodFnType.throwListLen]);

            args[0] = il::Val::Reg(try emitReserveLayout(self, layout));

        } else {

            args[0] = il::Val::Reg(try emitReserve(self, retTy));

        }

        let dst = nextReg(self);

        emit(self, il::Instr::Call {

            retTy: il::Type::W64,

            dst,

            func: il::Val::Reg(fnPtrReg),

            args,

        });

        return il::Val::Reg(dst);

    }

    // Scalar call: allocate destination register for non-void return types.

    let mut dst: ?il::Reg = nil;

    if retTy != resolver::Type::Void {

        retTy: ilType(self.low, retTy),

        if isSmallAggregate(retTy) {

            let slot = try emitReserveLayout(

                self,

                resolver::Layout {

                    size: resolver::PTR_SIZE,

                    alignment: resolver::PTR_SIZE

                });

            emit(self, il::Instr::Store {

                typ: il::Type::W64,

                src: il::Val::Reg(d),

                dst: slot,

                offset: 0,

            });

            return il::Val::Reg(slot);

        }

record Acc {

    n: i32,

}

trait Ops {

    fn (*Ops) get() -> i32;

    fn (*mut Ops) set(n: i32);

}

instance Ops for Acc {

    fn (a: *Acc) get() -> i32 {

        return a.n;

    }

    fn (a: *mut Acc) set(n: i32) {

        a.n = n;

    }

}

fn dispatch(o: *mut opaque Ops) -> i32 {

    o.set(42);

    return o.get();

}

data $"vtable::Acc::Ops" align 8 {

    fn $"Acc::get";

    fn $"Acc::set";

}

fn w32 $"Acc::get"(w64 %0) {

  @entry0

    sload w32 %1 %0 0;

    ret %1;

}

fn w32 $"Acc::set"(w64 %0, w32 %1) {

  @entry0

    store w32 %1 %0 0;

    ret;

}

fn w32 $dispatch(w64 %0) {

  @entry0

    load w64 %1 %0 0;

    load w64 %2 %0 8;

    load w64 %3 %2 8;

    call w32 %3(%1, 42);

    load w64 %4 %0 0;

    load w64 %5 %0 8;

    load w64 %6 %5 0;

    call w32 %7 %6(%4);

    ret %7;

}

record Counter {

    value: i32,

}

trait Adder {

    fn (*mut Adder) add(n: i32) -> i32;

}

instance Adder for Counter {

    fn (c: *mut Counter) add(n: i32) -> i32 {

        c.value = c.value + n;

        return c.value;

    }

}

fn use_adder() -> i32 {

    let mut c = Counter { value: 0 };

    let a: *mut opaque Adder = &mut c;

    return a.add(1);

}

data $"vtable::Counter::Adder" align 8 {

    fn $"Counter::add";

}

fn w32 $"Counter::add"(w64 %0, w32 %1) {

  @entry0

    sload w32 %2 %0 0;

    add w32 %3 %2 %1;

    store w32 %3 %0 0;

    sload w32 %4 %0 0;

    ret %4;

}

fn w32 $use_adder() {

  @entry0

    reserve %0 4 4;

    store w32 0 %0 0;

    reserve %1 16 8;

    store w64 %0 %1 0;

    store w64 $"vtable::Counter::Adder" %1 8;

    load w64 %2 %1 0;

    load w64 %3 %1 8;

    load w64 %4 %3 0;

    call w32 %5 %4(%2, 1);

    ret %5;

}

record Widget {

    x: i32,

}

trait Base {

    fn (*Base) get() -> i32;

}

trait Child: Base {

    fn (*mut Child) set(n: i32);

}

instance Base for Widget {

    fn (w: *Widget) get() -> i32 {

        return w.x;

    }

}

instance Child for Widget {

    fn (w: *mut Widget) set(n: i32) {

        w.x = n;

    }

}

data $"vtable::Widget::Base" align 8 {

    fn $"Widget::get";

}

data $"vtable::Widget::Child" align 8 {

    fn $"Widget::get";

    fn $"Widget::set";

}

fn w32 $"Widget::get"(w64 %0) {

  @entry0

    sload w32 %1 %0 0;

    ret %1;

}

fn w32 $"Widget::set"(w64 %0, w32 %1) {

  @entry0

    store w32 %1 %0 0;

    ret;

}

        // The receiver must be `*Type` or `*mut Type`.

        let case ast::NodeValue::TypeSig(typeSig) = receiverType.value

            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);

        let case ast::TypeSig::Pointer { mutable: receiverMut, valueType } = typeSig

            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);

        // Validate that the receiver type annotation matches the

        // concrete type from the instance declaration.

        let annotatedTy = try infer(self, valueType);

        if not typesEqual(annotatedTy, concreteType) {

            throw emitTypeMismatch(self, receiverType, TypeMismatch {

                expected: concreteType,

                actual: annotatedTy,

            });

        if let case Type::TraitObject { traitInfo, mutable: objMutable } = subjectTy {

            // Reject mutable-receiver methods called on immutable trait objects.

            if method.mutable and not objMutable {

                throw emitError(self, access.parent, ErrorKind::ImmutableBinding);

            }

    if let case super::ErrorKind::MissingSupertraitInstance(expectedName) = expected {

        if let case super::ErrorKind::MissingSupertraitInstance(actualName) = *actual {

            return mem::eq(actualName, expectedName);

        }

        return false;

    }

/// Calling a mutable-receiver trait method on an immutable trait object

/// must be rejected.

@test fn testResolveTraitMutMethodOnImmutableObject() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "record Counter { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { c.value = c.value + n; return c.value; } } fn caller(a: *opaque Adder) -> i32 { return a.add(1); }";

    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::ImmutableBinding);

}

/// Immutable methods on an immutable trait object should be accepted.

@test fn testResolveTraitImmutableMethodOnImmutableObject() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) get() -> i32; } instance Reader for Counter { fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(r: *opaque Reader) -> i32 { return r.get(); }";

    let result = try resolveProgramStr(&mut a, program);

    try expectNoErrors(&result);

}

/// Both mutable and immutable methods on a mutable trait object should work.

@test fn testResolveTraitMixedMethodsOnMutableObject() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "record Counter { value: i32 } trait Ops { fn (*mut Ops) inc(); fn (*Ops) get() -> i32; } instance Ops for Counter { fn (c: *mut Counter) inc() { c.value = c.value + 1; } fn (c: *Counter) get() -> i32 { return c.value; } } fn caller(o: *mut opaque Ops) -> i32 { o.inc(); return o.get(); }";

    let result = try resolveProgramStr(&mut a, program);

    try expectNoErrors(&result);

}

/// Instance method body type must match the trait return type.

/// The trait declares `-> i32` but the body returns `bool`.

@test fn testResolveInstanceReturnTypeMismatch() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "record R { x: i32 } trait T { fn (*T) get() -> i32; } instance T for R { fn (r: *R) get() -> bool { return true; } }";

    let result = try resolveProgramStr(&mut a, program);

    let err = try expectError(&result);

    let case super::ErrorKind::TypeMismatch(_) = err.kind

        else throw testing::TestError::Failed;

}

/// Diamond supertrait inheritance: traits B and C both extend A.

/// Declaring them independently should work fine.

@test fn testResolveTraitDiamondSupertrait() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; }";

    let result = try resolveProgramStr(&mut a, program);

    try expectNoErrors(&result);

}

/// Diamond supertrait with a combined trait that would cause duplicate

/// method names should be detected.

@test fn testResolveTraitDiamondDuplicateMethod() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "trait A { fn (*A) f() -> i32; } trait B: A { fn (*B) g() -> i32; } trait C: A { fn (*C) h() -> i32; } trait D: B + C { fn (*D) i() -> i32; }";

    let result = try resolveProgramStr(&mut a, program);

    // B inherits `f` from A, C inherits `f` from A. D: B + C sees duplicate `f`.

    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("f"));

}

/// Supertrait instance must exist when declaring a combined trait instance.

@test fn testResolveInstanceMissingSupertraitInstance() throws (testing::TestError) {

    let mut a = testResolver();

    let program = "trait Base { fn (*Base) f() -> i32; } trait Child: Base { fn (*Child) g() -> i32; } record R { x: i32 } instance Child for R { fn (r: *R) g() -> i32 { return r.x; } }";

    let result = try resolveProgramStr(&mut a, program);

    try expectErrorKind(&result, super::ErrorKind::MissingSupertraitInstance("Base"));

}