export record RecordType: Copy {

    fields: *[RecordField],

    labeled: bool,

    /// Cached layout.

    layout: Layout,

    declaredLinear: bool,

    /// Whether the declaration explicitly carries the `Copy` marker.

    declaredCopy: bool,

}

    layout: Layout,

    /// Cached payload offset within the union aggregate.

    valOffset: u32,

    /// If all variants have void payloads.

    isAllVoid: bool,

    declaredLinear: bool,

    /// Whether the declaration explicitly carries the `Copy` marker.

    declaredCopy: bool,

}

    LinearOverwrite,

    /// `undefined` cannot initialize a linear type.

    LinearUndefined,

    /// A `Copy` declaration contains a non-copy field or variant.

    CopyContainsNonCopy,

    ConflictingOwnershipMarkers,

    /// A reference appears in a storable or escaping position.

    InvalidRefPosition,

    /// A reference cannot be bound to a local.

    RefBinding,

    throws (ResolveError)

{

    let mut result = OwnershipMarkers { linear: false, copy: false };

    for derive in derives {

        let name = try nodeName(self, derive);

            if result.linear {

                throw emitError(self, derive, ErrorKind::DuplicateBinding(name));

            }

            if result.copy {

                throw emitError(self, derive, ErrorKind::ConflictingOwnershipMarkers);

        }

        case super::ErrorKind::CopyContainsNonCopy => {

            io::print("`Copy` composite contains a non-copy value");

        }

        case super::ErrorKind::ConflictingOwnershipMarkers => {

        }

        case super::ErrorKind::InvalidRefPosition => {

            io::print("reference type is only allowed as a function parameter");

        }

        case super::ErrorKind::RefBinding => {

}

/// References cannot escape through return types.

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

    let mut a = testResolver();

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

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

}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.

}

/// Unsafe pointer dereference requires an unsafe declaration.

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

    let mut a = testResolver();

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

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

}

/// Unsafe pointers remain freely copyable inside an unsafe declaration.

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

    try expectAnalyzeOk(program);

}

/// Safe code cannot call a function that accepts unsafe operations.

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

    let mut a = testResolver();

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

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

}

/// Unsafe function values retain their call-site safety requirement.

}

/// References cannot be embedded in aggregate fields.

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

    let mut a = testResolver();

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

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

}

/// Trait methods may use reference receivers.

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

    try expectAnalyzeOk(program);

}

/// Trait implementations must preserve the receiver pointer class.

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

}

/// A composite cannot carry conflicting ownership markers.

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

    let mut a = testResolver();

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

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

}

/// Linear composites still require one consuming use.

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

    let mut a = testResolver();

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

    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));

}

/// The compiler-known marker cannot be derived more than once.

    let mut a = testResolver();

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

}

    try expectAnalyzeOk(program);

}

/// References are rejected from every nested or storable type position.

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

    {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    }

}

/// Function pointer parameter references remain call-scoped and valid.

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

    try expectAnalyzeOk(program);

}

/// Pointer and slice casts cannot change reference ownership.

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

    {

        let mut a = testResolver();

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

        let err = try expectError(&result);

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

            else throw testing::TestError::Failed;

    } {

        let mut a = testResolver();

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

        let err = try expectError(&result);

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

            else throw testing::TestError::Failed;

    }

/// Every operation that interprets an unsafe address requires an unsafe declaration.

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

    {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    } {

        let mut a = testResolver();

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

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

    }

}

/// Unsafe declarations may compose unsafe operations and calls.

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

    try expectAnalyzeOk(program);

}

/// Unsafe code may drop a checked reference to an unsafe pointer.

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

    try expectAnalyzeOk(program);

}

/// Dropping a reference to an unsafe pointer cannot add mutability.

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

    let mut a = testResolver();

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.

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

    let mut a = testResolver();

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

/// Unsafe code may drop a checked slice reference to an unsafe slice.

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

    try expectAnalyzeOk(program);

}

/// Slice casts cannot add mutability.

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

    let mut a = testResolver();

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

    let err = try expectError(&result);

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

        else throw testing::TestError::Failed;

}

/// Mutable unsafe receivers do not create checked exclusive loans.

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

    try expectAnalyzeOk(program);

}

/// Unsafe instance-method attributes enable unsafe operations in the body.

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

    try expectAnalyzeOk(program);

}

/// Unsafe instance methods cannot implement safe trait contracts.

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

}

/// Unsafe trait methods retain their call-site requirement through dispatch.

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

    let mut a = testResolver();

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

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

}

//! returns: 42

/// Linear token consumed by the test.

    /// Token payload.

    Value(u32),

}

/// Consume a token and return its payload.

//! returns: 42

/// Linear counter borrowed and consumed by the test.

    /// Counter value.

    Value(u32),

}

/// Increment a borrowed counter.

//! returns: 42

/// Load a value through an unsafe pointer.

unsafe fn load(pointer: *unsafe u32) -> u32 {

    return *pointer;

}

" Keywords

syntax keyword radianceKeyword mod fn return if else while true false and or not case align static

syntax keyword radianceKeyword export break continue use loop in for match nil undefined

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

syntax keyword radianceKeyword throws throw try catch panic assert super unsafe

" Double-quoted strings

syntax region radianceString start=/"/ skip=/\\"/ end=/"/ contains=radianceEscape

" Characters

syntax region radianceCharacter start=/'/ skip=/\\'|\\\\/ end=/'/ oneline contains=radianceEscape