//! Test trait dispatch inside control flow.

//!

//! Exercises: trait method calls inside loops and conditionals,

//! verifying that vtable dispatch works correctly when interleaved

//! with branching and iteration.

record Counter {

    value: i32,

}

trait Stepper {

    fn (*mut Stepper) step() -> i32;

    fn (*Stepper) current() -> i32;

}

instance Stepper for Counter {

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

        c.value = c.value + 1;

        return c.value;

    }

    fn (c: *Counter) current() -> i32 {

        return c.value;

    }

}

@default fn main() -> i32 {

    let mut c = Counter { value: 0 };

    let s: *mut opaque Stepper = &mut c;

    // Dispatch in a while loop.

    let mut i: i32 = 0;

    while i < 5 {

        s.step();

        i = i + 1;

    }

    if s.current() != 5 {

        return 1;

    }

    // Dispatch in a conditional.

    if s.current() > 3 {

        s.step();

    }

    if s.current() != 6 {

        return 2;

    }

    // Dispatch result used as loop condition.

    while s.current() < 10 {

        s.step();

    }

    if s.current() != 10 {

        return 3;

    }

    // Dispatch result used in conditional expression.

    let v = s.current();

    if v != 10 {

        return 4;

    }

    return 0;

}

//! Test passing trait objects as function parameters.

//!

//! Exercises: trait objects passed to non-method functions, including

//! both mutable and immutable trait object pointers as arguments.

record Circle {

    radius: i32,

}

record Square {

    side: i32,

}

trait Shape {

    fn (*Shape) area() -> i32;

}

trait Scalable {

    fn (*mut Scalable) scale(factor: i32);

}

instance Shape for Circle {

    fn (c: *Circle) area() -> i32 {

        return c.radius * c.radius * 3;

    }

}

instance Shape for Square {

    fn (s: *Square) area() -> i32 {

        return s.side * s.side;

    }

}

instance Scalable for Circle {

    fn (c: *mut Circle) scale(factor: i32) {

        c.radius = c.radius * factor;

    }

}

/// Accept an immutable trait object parameter.

fn getArea(s: *opaque Shape) -> i32 {

    return s.area();

}

/// Accept a mutable trait object parameter.

fn doubleSize(s: *mut opaque Scalable) {

    s.scale(2);

}

/// Accept two trait object parameters.

fn totalArea(a: *opaque Shape, b: *opaque Shape) -> i32 {

    return a.area() + b.area();

}

@default fn main() -> i32 {

    let c = Circle { radius: 5 };

    let s = Square { side: 4 };

    // Pass immutable trait objects to function.

    let cs: *opaque Shape = &c;

    let ca = getArea(cs);

    if ca != 75 {

        return 1;

    }

    let ss: *opaque Shape = &s;

    let sa = getArea(ss);

    if sa != 16 {

        return 2;

    }

    // Pass two different trait objects to same function.

    let total = totalArea(cs, ss);

    if total != 91 {

        return 3;

    }

    // Pass mutable trait object to function.

    let mut c2 = Circle { radius: 3 };

    let sc: *mut opaque Scalable = &mut c2;

    doubleSize(sc);

    if c2.radius != 6 {

        return 4;

    }

    return 0;

}

//! Test trait with multiple methods and mixed return types.

//!

//! Exercises: a trait declaring multiple methods with void, bool, and

//! integer return types. Verifies vtable layout with more than one

//! entry and correct dispatch for each method.

record Accumulator {

    total: i32,

}

trait Collector {

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

    fn (*mut Collector) clear();

    fn (*mut Collector) isEmpty() -> bool;

}

instance Collector for Accumulator {

    fn (a: *mut Accumulator) add(n: i32) -> i32 {

        a.total = a.total + n;

        return a.total;

    }

    fn (a: *mut Accumulator) clear() {

        a.total = 0;

    }

    fn (a: *mut Accumulator) isEmpty() -> bool {

        return a.total == 0;

    }

}

@default fn main() -> i32 {

    let mut acc = Accumulator { total: 0 };

    let c: *mut opaque Collector = &mut acc;

    // Initially empty.

    if not c.isEmpty() {

        return 1;

    }

    // Add returns running total.

    let v1 = c.add(10);

    if v1 != 10 {

        return 2;

    }

    let v2 = c.add(20);

    if v2 != 30 {

        return 3;

    }

    // No longer empty.

    if c.isEmpty() {

        return 4;

    }

    // Void return: clear.

    c.clear();

    if acc.total != 0 {

        return 5;

    }

    if not c.isEmpty() {

        return 6;

    }

    return 0;

}

//! Test one type implementing multiple traits.

//!

//! Exercises: a single concrete type that provides instances for

//! two different traits. Each trait object dispatches independently

//! through its own vtable.

record Counter {

    value: i32,

}

trait Incrementable {

    fn (*mut Incrementable) inc() -> i32;

}

trait Resettable {

    fn (*mut Resettable) reset();

    fn (*mut Resettable) isZero() -> bool;

}

instance Incrementable for Counter {

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

        c.value = c.value + 1;

        return c.value;

    }

}

instance Resettable for Counter {

    fn (c: *mut Counter) reset() {

        c.value = 0;

    }

    fn (c: *mut Counter) isZero() -> bool {

        return c.value == 0;

    }

}

@default fn main() -> i32 {

    let mut c = Counter { value: 10 };

    // Dispatch through Incrementable.

    let i: *mut opaque Incrementable = &mut c;

    let v1 = i.inc();

    if v1 != 11 {

        return 1;

    }

    // Dispatch through Resettable.

    let r: *mut opaque Resettable = &mut c;

    if r.isZero() {

        return 2;

    }

    r.reset();

    if not r.isZero() {

        return 3;

    }

    if c.value != 0 {

        return 4;

    }

    // Increment again after reset.

    let v2 = i.inc();

    if v2 != 1 {

        return 5;

    }

    return 0;

}

//! Test multiple types implementing the same trait, and immutable receivers.

//!

//! Exercises: two different concrete types implementing the same trait,

//! coerced to the same trait object type. Also tests immutable `*Trait`

//! receivers. Verifies each type dispatches through its own vtable.

record Dog {

    age: i32,

}

record Cat {

    lives: i32,

}

trait Speaker {

    fn (*Speaker) speak() -> i32;

    fn (*Speaker) isOld() -> bool;

}

instance Speaker for Dog {

    fn (d: *Dog) speak() -> i32 {

        return d.age;

    }

    fn (d: *Dog) isOld() -> bool {

        return d.age > 10;

    }

}

instance Speaker for Cat {

    fn (c: *Cat) speak() -> i32 {

        return c.lives * 10;

    }

    fn (c: *Cat) isOld() -> bool {

        return c.lives < 5;

    }

}

@default fn main() -> i32 {

    let d = Dog { age: 5 };

    let c = Cat { lives: 9 };

    // Immutable trait object from Dog.

    let sd: *opaque Speaker = &d;

    let v1 = sd.speak();

    if v1 != 5 {

        return 1;

    }

    if sd.isOld() {

        return 2;

    }

    // Immutable trait object from Cat.

    let sc: *opaque Speaker = &c;

    let v2 = sc.speak();

    if v2 != 90 {

        return 3;

    }

    if sc.isOld() {

        return 4;

    }

    // Old dog.

    let oldDog = Dog { age: 15 };

    let so: *opaque Speaker = &oldDog;

    if not so.isOld() {

        return 5;

    }

    return 0;

}

//! Test realistic trait usage: a Writer abstraction with multiple backends.

//!

//! Exercises: a Writer trait used to abstract over different output targets.

//! A BufferWriter writes to an in-memory buffer; a CountingWriter wraps any

//! Writer and tracks how many bytes flow through it. This tests trait objects

//! as struct fields, dispatch chains, and a real-world composition pattern.

trait Writer {

    fn (*mut Writer) write(data: *[u8]) -> i32;

    fn (*Writer) total() -> i32;

}

/// Writes bytes into a fixed-size buffer.

record BufferWriter {

    buf: [u8; 64],

    pos: i32,

}

instance Writer for BufferWriter {

    fn (w: *mut BufferWriter) write(data: *[u8]) -> i32 {

        let mut i: u32 = 0;

        while i < data.len {

            if w.pos >= 64 {

                return w.pos;

            }

            w.buf[w.pos as u32] = data[i];

            w.pos = w.pos + 1;

            i = i + 1;

        }

        return w.pos;

    }

    fn (w: *BufferWriter) total() -> i32 {

        return w.pos;

    }

}

/// Counts bytes written through it, forwarding to an inner writer.

record CountingWriter {

    inner: *mut opaque Writer,

    count: i32,

}

instance Writer for CountingWriter {

    fn (w: *mut CountingWriter) write(data: *[u8]) -> i32 {

        w.count = w.count + data.len as i32;

        return w.inner.write(data);

    }

    fn (w: *CountingWriter) total() -> i32 {

        return w.count;

    }

}

/// Write a slice through any Writer.

fn emit(w: *mut opaque Writer, data: *[u8]) -> i32 {

    return w.write(data);

}

@default fn main() -> i32 {

    // Direct BufferWriter usage through trait.

    let mut buf = BufferWriter { buf: undefined, pos: 0 };

    let w: *mut opaque Writer = &mut buf;

    emit(w, "hello");

    if w.total() != 5 {

        return 1;

    }

    emit(w, " world");

    if w.total() != 11 {

        return 2;

    }

    // Verify buffer contents.

    if buf.buf[0] != 'h' as u8 {

        return 3;

    }

    if buf.buf[4] != 'o' as u8 {

        return 4;

    }

    if buf.buf[5] != ' ' as u8 {

        return 5;

    }

    if buf.buf[10] != 'd' as u8 {

        return 6;

    }

    // Counting writer wrapping a buffer writer.

    let mut buf2 = BufferWriter { buf: undefined, pos: 0 };

    let bw2: *mut opaque Writer = &mut buf2;

    let mut cw = CountingWriter { inner: bw2, count: 0 };

    let w2: *mut opaque Writer = &mut cw;

    emit(w2, "abc");

    if cw.count != 3 {

        return 7;

    }

    // Underlying buffer also received the bytes.

    if buf2.pos != 3 {

        return 8;

    }

    emit(w2, "defgh");

    if cw.count != 8 {

        return 9;

    }

    if buf2.pos != 8 {

        return 10;

    }

    // Check buf2 contents were forwarded correctly.

    if buf2.buf[0] != 'a' as u8 {

        return 11;

    }

    if buf2.buf[3] != 'd' as u8 {

        return 12;

    }

    if buf2.buf[7] != 'h' as u8 {

        return 13;

    }

    return 0;

}

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

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

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

    let mut a = testResolver();

    let program = "trait Adder { fn (*mut Adder) add(n: i32) -> i32; fn (*mut Adder) add(n: i32) -> i32; }";

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

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

}

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

    let mut a = testResolver();

    let program = "record Counter { value: i32 } record Wrong { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Counter { fn (c: *mut Wrong) add(n: i32) -> i32 { return n; } }";

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

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

    let mut a = testResolver();

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

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

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

}

/// Trait declares immutable receiver (*Trait) but instance uses mutable (*mut Type).

/// The instance method could mutate through what was originally an immutable pointer.

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

    let mut a = testResolver();

    let program = "record Counter { value: i32 } trait Reader { fn (*Reader) read() -> i32; } instance Reader for Counter { fn (c: *mut Counter) read() -> i32 { c.value = c.value + 1; return c.value; } }";

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

    // Should reject: instance declares *mut receiver but trait only requires immutable.

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

}

/// Instance method declares different parameter types than the trait.

/// The resolver should reject the mismatch rather than silently using the trait's types.

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

    let mut a = testResolver();

    let program = "record Acc { value: i32 } trait Adder { fn (*mut Adder) add(n: i32) -> i32; } instance Adder for Acc { fn (a: *mut Acc) add(n: u8) -> i32 { a.value = a.value + n as i32; return a.value; } }";

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

    // Should reject: instance param type u8 doesn't match trait param type i32.

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

/// Duplicate instance declarations for the same (trait, type) pair should be rejected.

@test fn testResolveInstanceDuplicateRejected() 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; } } instance Adder for Counter { fn (c: *mut Counter) add(n: i32) -> i32 { c.value = c.value + n + 100; return c.value; } }";

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

    // Should reject: duplicate instance for (Adder, Counter).

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

}

/// Trait method receiver must point to the declaring trait type.

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

    let mut a = testResolver();

    let program = "record Other { x: i32 } trait Foo { fn (*mut Other) bar() -> i32; }";

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

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

}

/// Using a trait name as a value expression should be rejected.

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

    let mut a = testResolver();

    let program = "trait Foo { fn (*Foo) bar() -> i32; } fn test() -> i32 { let x = Foo; return 0; }";

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

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

}

/// Cross-module trait: coerce to trait object and dispatch from a different module.

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

    let mut a = testResolver();

    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod defs; mod app;", &mut arena);

    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub 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; } }", &mut arena);

    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);

    try expectNoErrors(&result);

}

/// Instance in a different module from trait and type.

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

    let mut a = testResolver();

    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);

    let rootId = try registerModule(&mut MODULE_GRAPH, nil, "root", "pub mod defs; pub mod impls; mod app;", &mut arena);

    let defsId = try registerModule(&mut MODULE_GRAPH, rootId, "defs", "pub record Counter { value: i32 } pub trait Adder { fn (*mut Adder) add(n: i32) -> i32; }", &mut arena);

    let implsId = try registerModule(&mut MODULE_GRAPH, rootId, "impls", "use root::defs; instance defs::Adder for defs::Counter { fn (c: *mut defs::Counter) add(n: i32) -> i32 { c.value = c.value + n; return c.value; } }", &mut arena);

    let appId = try registerModule(&mut MODULE_GRAPH, rootId, "app", "use root::defs; fn test() -> i32 { let mut c = defs::Counter { value: 10 }; let a: *mut opaque defs::Adder = &mut c; return a.add(5); }", &mut arena);

    let result = try resolveModuleTree(&mut a, rootId);

    try expectNoErrors(&result);

}

syntax keyword radianceKeyword let mut as register device const log record union trait instance