and p.current.kind <> scanner::TokenKind::Static

            throw failParsing(p, "`unsafe` is only allowed on functions, blocks, and statics");

/// Unsafe static declarations carry an explicit access requirement.

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

    let parsed = try? parseStmtsStr("export unsafe static DATA: [u8; 4] = undefined;");

    try testing::expect(parsed <> nil);

}

/// Require an unsafe context for any access to an unsafe static.

unsafe fn checkStaticAccess(self: &mut Resolver, node: *ast::Node, sym: &Symbol)

    throws (ResolveError)

{

    if let case ast::NodeValue::StaticDecl(_) = sym.node.value {

        if ast::hasAttribute(sym.attrs, ast::Attribute::Unsafe) {

            try requireUnsafe(self, node);

        }

    }

}

            try checkStaticAccess(self, node, sym);

    let wasUnsafe = self.inUnsafeContext;

    set self.inUnsafeContext = wasUnsafe or (

        not isConst and ast::hasAttribute(attrs, ast::Attribute::Unsafe)

    );

    let valueTy = try checkAssignable(self, valueNode, bindingTy) catch e {

        set self.inUnsafeContext = wasUnsafe;

        throw e;

    };

    set self.inUnsafeContext = wasUnsafe;

    try checkStaticAccess(self, node, sym);

/// Unsafe statics require unsafe permission for reads, writes, and addresses.

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

    let programs = &[

        "unsafe static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }",

        "unsafe static VALUE: u32 = 7; fn run() { set VALUE = 8; }",

        "unsafe static VALUE: u32 = 7; fn run() -> *u32 { return &VALUE; }",

        "unsafe static VALUE: u32 = 7; fn run() -> *mut u32 { return &mut VALUE; }",

        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u8 { return DATA[0]; }",

        "unsafe static DATA: [u8; 1] = [42]; fn run() -> u32 { return DATA.len; }",

        "record R { value: u32 } unsafe static DATA: R = R { value: 7 }; fn run() -> u32 { return DATA.value; }",

    ];

    for program in programs {

        let mut a = testResolver();

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

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

    }

}

/// Unsafe blocks and functions can access unsafe statics.

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

    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; unsafe fn run() -> u32 { set VALUE = 8; return VALUE; }");

    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; fn run() -> u32 { unsafe { return VALUE; } }");

    try expectAnalyzeOk("unsafe static VALUE: u32 = 7; unsafe fn run() -> *mut u32 { return &mut VALUE; }");

    try expectAnalyzeOk("static VALUE: u32 = 7; fn run() -> u32 { return VALUE; }");

    try expectAnalyzeOk("constant BYTES: *[u8] = \"x\"; unsafe static DATA: *[u64] = BYTES as *[u64];");

}

/// Imports preserve the unsafe access requirement of a static.

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

    let programs = &[

        "use root::storage; fn run() -> u32 { return storage::VALUE; }",

        "use root::storage::*; fn run() -> u32 { return VALUE; }",

    ];

    for program in programs {

        let mut a = testResolver();

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

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

        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "storage", "export unsafe static VALUE: u32 = 7;", &mut arena);

        let _ = try registerModule(&mut MODULE_GRAPH, rootId, "app", program, &mut arena);

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

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

    }

}

/// An invalid unsafe static initializer does not grant permission to other initializers.

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

    let mut a = testResolver();

    let result = try resolveProgramStr(&mut a, "unsafe static BAD: u32 = true; static DATA: *[u64] = &[1 as u8] as *[u64];");

    let _ = try expectError(&result);

    try testing::expect(not a.inUnsafeContext);

    let mut b = testResolver();

    let next = try resolveProgramStr(&mut b, "constant BYTES: *[u8] = \"x\"; unsafe static VALUE: u32 = 7; static DATA: *[u64] = BYTES as *[u64];");

    try expectErrorKind(&next, super::ErrorKind::UnsafeOperation);

}

//! returns: 0

/// Storage whose accesses require an unsafe context.

unsafe static VALUE: u8 = 7;

/// Pointer storage initialized before its first read.

unsafe static POINTER: *u8 = undefined;

/// Set the pointer to initialized permanent storage and read its value.

fn read() -> u8 {

    unsafe {

        set VALUE = 8;

        set POINTER = &VALUE;

        return *POINTER;

    }

}

/// Exercise unsafe static access through a safe function.

@default fn main() -> i32 {

    if read() <> 8 { return 1; }

    return 0;

}