//! rejects: 31:49: parameter of the default function after the environment must have type `*mut T` //! rejects: 36:53: parameter of the default function after the environment must have type `*mut T` //! rejects: 41:46: parameter of the default function after the environment must have type `*mut T` //! rejects: 46:44: parameter of the default function after the environment must have type `*mut T` //! rejects: 51:30: parameter of the default function after the environment must have type `*mut T` //! rejects: 56:39: parameter of the default function after the environment must have type `*mut T` //! rejects: 61:42: parameter of the default function after the environment must have type `*mut T` //! rejects: 66:53: parameter of the default function after the environment must have type `*mut T` //! rejects: 71:49: parameter of the default function after the environment must have type `*mut T` //! rejects: 76:37: type of a default function storage parameter must be valid when zero-filled //! rejects: 81:46: type of a default function storage parameter must be valid when zero-filled //! rejects: 86:34: type of a default function storage parameter must be valid when zero-filled //! rejects: 97:39: type of a default function storage parameter must be valid when zero-filled //! rejects: 110:28: type of a default function storage parameter must be valid when zero-filled //! rejects: 123:28: type of a default function storage parameter must be valid when zero-filled //! rejects: 136:40: type of a default function storage parameter must be valid when zero-filled //! rejects: 147:45: type of a default function storage parameter must be valid when zero-filled //! rejects: 158:29: type of a default function storage parameter must be valid when zero-filled //! Parameters of the default function after the environment must be owned //! mutable pointers to types that are valid when zero-filled. use std::sys; /// Record that is valid when zero-filled. record Good { /// Integer field. n: u32, } /// Immutable pointer to an array. @default fn immutable(env: *sys::Env, a: *[u8; 8]) -> i32 { return 0; } /// Reference to an array. @default fn reference(env: *sys::Env, a: &mut [u8; 8]) -> i32 { return 0; } /// Slice of unknown size. @default fn slice(env: *sys::Env, a: *mut [u8]) -> i32 { return 0; } /// Unsafe pointer to an array. @default fn unsafePtr(a: *unsafe mut [u8; 8]) -> i32 { return 0; } /// Array by value. @default fn byValue(a: [u8; 8]) -> i32 { return 0; } /// Ordinary extra parameter after the environment. @default fn scalar(env: *sys::Env, n: u32) -> i32 { return 0; } /// Extra parameter after a valid storage parameter. @default fn trailing(a: *mut [u8; 8], n: u32) -> i32 { return 0; } /// Reference to a record. @default fn recordReference(env: *sys::Env, a: &mut Good) -> i32 { return 0; } /// Immutable pointer to a record. @default fn recordImmutable(env: *sys::Env, a: *Good) -> i32 { return 0; } /// Pointer elements are not valid when zero-filled. @default fn pointers(a: *mut [*u8; 8]) -> i32 { return 0; } /// A pointer is not valid when zero-filled. @default fn pointer(env: *sys::Env, a: *mut *u8) -> i32 { return 0; } /// Function pointers are not valid when zero-filled. @default fn functions(a: *mut fn()) -> i32 { return 0; } /// A record with a pointer field is not valid when zero-filled. record Linked { /// Pointer field. next: *Linked, } /// Record elements are valid only when all their fields are. @default fn records(a: *mut [Linked; 8]) -> i32 { return 0; } /// Record that holds a nested record with a pointer field. record Nested { /// Integer field. n: u32, /// Nested record. inner: Linked, } /// A nested record counts. @default fn nested(a: *mut Nested) -> i32 { return 0; } /// Union whose zero tag has a pointer payload. union Pointed { /// Variant with tag 0. First(*u8), /// Variant without payload. Second, } /// A union is valid when zero-filled only if its tag 0 variant is. @default fn unions(a: *mut Pointed) -> i32 { return 0; } /// Union without a variant with tag 0. union Late { /// Explicit tag 1. First = 1, /// Explicit tag 2. Second = 2, } /// A union without tag 0 has no zero value. @default fn lateUnions(a: *mut [Late; 2]) -> i32 { return 0; } /// Record with a field of a union without tag 0. record Holder { /// Union field. late: Late, } /// A record with such a field has no zero value. @default fn holders(env: *sys::Env, a: *mut Holder) -> i32 { return 0; } /// Record that must be consumed once. record Ticket: Once { /// Integer field. n: u32, } /// Linear types are not valid when zero-filled. @default fn tickets(a: *mut Ticket) -> i32 { return 0; } /// Storage-like parameters of an ordinary function are ordinary parameters. fn ordinary(a: *[u8; 8], b: &mut [bool; 2], c: *mut [u8], d: *mut *u8) {}