//! Module-owned record representation tests.

use std::testing;

use std::io;

use std::lang::ast;

use std::lang::resolver;

use super::tests;

/// Types used to check access to module-owned record representations.

constant OPAQUE_RECORD_MODEL: *[u8] = "export opaque record Value: Copy { number: u32 } export opaque record Word: Copy(u32); export opaque record Empty: Copy {} export opaque record View: 'r + Copy { number: &'r cell u32 } opaque record Hidden: Copy { number: u32 } export fn hidden() -> Hidden { return Hidden { number: 42 }; } export union Wrapped: Copy { Value(Value) }";

/// External record operations cannot expose or construct private fields.

@test unsafe fn testOpaqueRecordAccess() throws (testing::TestError) {

    for program in [

        "mod model; fn f(p: model::Value) -> u32 { return p.number; }",

        "mod model; fn f(p: &model::Value) -> u32 { return p.number; }",

        "mod model; fn f(p: &mut model::Value) { set p.number = 1; }",

        "mod model; fn f(p: &mut model::Value) { set p.number += 1; }",

        "mod model; fn f(p: &model::Value) { let field = &p.number; }",

        "mod model; fn f(p: &mut model::Value) { let field = &mut p.number; }",

        "mod model; unsafe fn f(p: model::Value) -> u32 { return p.number; }",

        "mod model; fn f() -> u32 { return model::hidden().number; }",

        "mod model; fn f() -> model::Value { return model::Value { number: 1 }; }",

        "mod model; fn f() -> model::Value { return { number: 1 }; }",

        "mod model; fn f() -> ?model::Value { return { number: 1 }; }",

        "mod model; fn f() -> model::Value { return model::Value { .. }; }",

        "mod model; fn f() -> model::Empty { return model::Empty {}; }",

        "mod model; fn f() -> model::Word { return model::Word(1); }",

        "mod model; fn f(p: model::Value) { let case model::Value { number } = p else panic; }",

        "mod model; fn f(p: &model::Value) { let case model::Value { number } = p else panic; }",

        "mod model; fn f(p: model::Value) { let case model::Value { .. } = p else panic; }",

        "mod model; fn f(p: model::Value) { if let case model::Value { number } = p; number > 0 {} }",

        "mod model; fn f(p: model::Value) { while let case model::Value { number } = p { break; } }",

        "mod model; fn f(p: model::Value) { match p { case model::Value { number } => {} } }",

        "mod model; fn f(p: model::Wrapped) { match p { case model::Wrapped::Value(model::Value { number }) => {} } }",

        "mod model; fn f(p: model::Word) { let case model::Word(number) = p else panic; }",

        "mod model; fn f(p: model::Word) -> u32 { return *p; }",

        "mod model; fn f(p: &mut model::Word) { set **p = 2; }",

        "mod model; fn f(p: model::Word) { let field = &*p; }",

        "mod model; fn f 'r (p: &model::View 'r) -> u32 { return *p.number; }",

        "mod model; fn f 'r (p: &model::View 'r) { set *p.number = 1; }",

        "mod model; fn f 'r (number: &'r cell u32) -> model::View 'r { return model::View 'r { number }; }",

        "mod model; fn f 'r (number: &'r cell u32) -> model::View 'r { return { number }; }",

        "mod model; fn f 'r (p: model::View 'r) { let case model::View 'r { number } = p else panic; }",

        "mod model; use root::model::*; fn f(p: Value) -> u32 { return p.number; }",

    ] {

        let mut storage = tests::testArena();

        let memory: 'test = &mut storage in {

            let mut res = tests::testResolver(memory);

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

            let root = try tests::registerModule(&mut tests::MODULE_GRAPH, nil, "root", program, &mut arena);

            let model = try tests::registerModule(&mut tests::MODULE_GRAPH, root, "model", OPAQUE_RECORD_MODEL, &mut arena);

            let result = try tests::resolveModuleTree(&mut res, root);

            try tests::expectErrorKind(&result, resolver::ErrorKind::OpaqueRecordAccess) catch error {

                io::print(program);

                io::print("\n");

                tests::printDiagnostics(&result.diagnostics, &res);

                throw error;

            };

        }

    }

}

/// Child and sibling modules cannot access an opaque record's fields.

@test unsafe fn testOpaqueRecordModuleBoundary() throws (testing::TestError) {

    for child in [false, true] {

        let mut storage = tests::testArena();

        let memory: 'test = &mut storage in {

            let mut res = tests::testResolver(memory);

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

            let root = try tests::registerModule(&mut tests::MODULE_GRAPH, nil, "root", "export mod model; mod client;", &mut arena);

            let model = try tests::registerModule(&mut tests::MODULE_GRAPH, root, "model", "mod child; export opaque record Value: Copy { number: u32 }", &mut arena);

            let program = "use root::model; fn f(p: model::Value) -> u32 { return p.number; }";

            let nested = try tests::registerModule(&mut tests::MODULE_GRAPH, model, "child", program if child else "", &mut arena);

            let client = try tests::registerModule(&mut tests::MODULE_GRAPH, root, "client", "" if child else program, &mut arena);

            let result = try tests::resolveModuleTree(&mut res, root);

            try tests::expectErrorKind(&result, resolver::ErrorKind::OpaqueRecordAccess) catch error {

                tests::printDiagnostics(&result.diagnostics, &res);

                throw error;

            };

        }

    }

}

/// Defining modules can access opaque representations through all source forms.

@test unsafe fn testOpaqueRecordLocalAccess() throws (testing::TestError) {

    let mut storage = tests::testArena();

    let memory: 'test = &mut storage in {

        let mut res = tests::testResolver(memory);

        let result = try tests::resolveProgramStr(&mut res,

            "opaque record Value: Copy { number: u32 } opaque record Word: Copy(u32); opaque record View: 'r + Copy { number: &'r cell u32 } fn f() { let mut p = Value { number: 1 }; set p.number += 2; let q: Value = { number: p.number }; let r: ?Value = { number: 4 }; let case Value { number } = q else panic; if let case Value { number: n } = p; n > 0 {} while let case Value { number: n } = p { break; } match p { case Value { number: n } => {} else => {} } let mut w = Word(1); set *w = 2; { let field = &mut *w; set *field = 3; } let case Word(n) = w else panic; } fn g 'r (number: &'r cell u32) -> View 'r { let p = View 'r { number }; set *p.number = 42; let case View 'r { number: value } = p else panic; return { number: value }; }"

        );

        try tests::expectNoErrors(&result) catch error {

            tests::printDiagnostics(&result.diagnostics, &res);

            throw error;

        };

    }

}