Struct EventDecl 

pub struct EventDecl {
    pub name: Ident,
    pub annotations: Vec<Annotation>,
    pub body: RecordBody,
    pub documentation: Option<String>,
    pub span: Span,
    pub trivia: Trivia,
}

event Name = { fields } — a typed fact a context may emit and other contexts’ subscriber services may receive (Events track, slice 0, spine #936). Record body only in slice 0 — pattern refinement (subscription side, slice 1) and default-valued fields for additive versioning (slice 3a) both extend a record body, so nothing here forecloses them. An optional @schema(N) annotation (slice 3b) asserts the event’s current wire schema version, embedded into env.schemaVersion at emission — see EventDecl::schema_version. Legal only inside a context — checker-enforced (bynk.event.outside_context), not grammar, mirroring how capability/provides are commons-rejected at the parser while event instead follows messages’ precedent (ADR 0272) of parsing uniformly and letting the checker place it, since unlike capability/provides an event has no meaning to reject early inside an adapter either.

Fields

name: Ident

annotations: Vec<Annotation>

Every @-annotation attached to this declaration. The parser stays permissive (zero or more, same as store field / messages annotations); the closed registry (today: @schema alone) and its argument shape are a checker concern (bynk.event.unknown_annotation / bynk.event.bad_schema_version), not a parse error.

body: RecordBody

documentation: Option<String>

Documentation block attached to this declaration.

span: Span

trivia: Trivia

Implementations

impl EventDecl

pub fn as_type_decl(&self) -> TypeDecl

A synthetic TypeDecl with this event’s name and record body, so an event registers into the ordinary types symbol table and reuses every existing type-reference/exports/consumes/construction check — no non-generic type parameters, no separate resolution path. Callers that need to know a name is specifically an event (owner-only emission, from Events(E)/Events.emit[E]’s “must be an event, not just any type” gate) track that separately, alongside this.

Deliberately lossy: a TypeDecl has no annotations, so @schema(N) does not survive this conversion. Nothing downstream of this synthesis needs the event’s schema version — only the emitter’s own Events.emit lowering does, and it reads EventDecl::schema_version directly off the real declaration instead.

pub fn schema_version(&self) -> i64

This event’s declared wire schema version (Events slice 3b, #978): the positive Int literal argument of its sole @schema(N) annotation, or 1 if the annotation is absent — identical to every event’s behaviour before this annotation existed. A malformed @schema (non-positive, non-literal, wrong arity, labelled, or duplicated) has already been reported by the checker (bynk.event.bad_schema_version); this falls back to 1 rather than re-deriving that diagnostic.

Trait Implementations

impl Clone for EventDecl

fn clone(&self) -> EventDecl

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for EventDecl

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.