1pub mod rr {
4 #[derive(Debug, Clone, enum_as_inner::EnumAsInner)]
5 #[allow(non_camel_case_types)]
6 pub enum Program {
7 SqlPostgres(crate::boxed::Box<SqlProgram>),
8 SqlDuckDb(crate::boxed::Box<SqlProgram>),
9 BytecodeLt(super::br::Program),
10 }
11
12 #[derive(Debug, Clone)]
13 #[allow(non_camel_case_types)]
14 pub struct ProgramType {
15 pub input: super::ir::Ty,
16 pub output: super::ir::Ty,
17 pub defs: crate::vec::Vec<super::ir::TyDef>,
18 }
19
20 #[derive(Debug, Clone)]
21 #[allow(non_camel_case_types)]
22 pub struct SqlProgram {
23 pub sql: crate::string::String,
24 pub input_ty: super::ir::Ty,
25 pub output_ty: super::ir::Ty,
26 pub defs: crate::vec::Vec<super::ir::TyDef>,
27 }
28
29 mod impls {
30 #![allow(unused_imports)]
31 use super::*;
32 use crate::ReaderExt;
33 use crate::bytes::BufMut;
34
35 #[allow(unused_variables)]
36 #[allow(clippy::all)]
37 impl crate::Encode for Program {
38 type HeadPtr = ProgramHeadPtr;
39 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> ProgramHeadPtr {
40 match self {
41 Self::SqlPostgres(inner) => {
42 w.put_slice(&[0]);
43 let head_ptr = crate::ReversePointer::new(w);
44 let r = ProgramHeadPtr::SqlPostgres(head_ptr);
45 r
46 }
47 Self::SqlDuckDb(inner) => {
48 w.put_slice(&[1]);
49 let head_ptr = crate::ReversePointer::new(w);
50 let r = ProgramHeadPtr::SqlDuckDb(head_ptr);
51 r
52 }
53 Self::BytecodeLt(inner) => {
54 w.put_slice(&[2]);
55 let head_ptr = crate::ReversePointer::new(w);
56 let r = ProgramHeadPtr::BytecodeLt(head_ptr);
57 r
58 }
59 }
60 }
61 fn encode_body(&self, head: ProgramHeadPtr, w: &mut crate::bytes::BytesMut) {
62 match self {
63 Self::SqlPostgres(inner) => {
64 let ProgramHeadPtr::SqlPostgres(offset_ptr) = head else {
65 unreachable!()
66 };
67 offset_ptr.write_cur_len(w);
68 let inner_head_ptr = inner.encode_head(w);
69 inner.encode_body(inner_head_ptr, w);
70 }
71 Self::SqlDuckDb(inner) => {
72 let ProgramHeadPtr::SqlDuckDb(offset_ptr) = head else {
73 unreachable!()
74 };
75 offset_ptr.write_cur_len(w);
76 let inner_head_ptr = inner.encode_head(w);
77 inner.encode_body(inner_head_ptr, w);
78 }
79 Self::BytecodeLt(inner) => {
80 let ProgramHeadPtr::BytecodeLt(offset_ptr) = head else {
81 unreachable!()
82 };
83 offset_ptr.write_cur_len(w);
84 let inner_head_ptr = inner.encode_head(w);
85 inner.encode_body(inner_head_ptr, w);
86 }
87 }
88 }
89 }
90 #[allow(non_camel_case_types, dead_code)]
91 pub enum ProgramHeadPtr {
92 None,
93 SqlPostgres(crate::ReversePointer),
94 SqlDuckDb(crate::ReversePointer),
95 BytecodeLt(crate::ReversePointer),
96 }
97 impl crate::Layout for Program {
98 fn head_size() -> usize {
99 40
100 }
101 }
102
103 impl crate::Decode for Program {
104 fn decode(buf: &[u8]) -> crate::Result<Self> {
105 let mut tag_bytes = buf.read_n(1).to_vec();
106 tag_bytes.resize(8, 0);
107 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
108 let buf = buf.skip(1);
109 Ok(match tag {
110 0 => {
111 let offset = u32::from_le_bytes(buf.read_const::<4>());
112 let inner = super::SqlProgram::decode(buf.skip(offset as usize))?;
113 Program::SqlPostgres(crate::boxed::Box::new(inner))
114 }
115 1 => {
116 let offset = u32::from_le_bytes(buf.read_const::<4>());
117 let inner = super::SqlProgram::decode(buf.skip(offset as usize))?;
118 Program::SqlDuckDb(crate::boxed::Box::new(inner))
119 }
120 2 => {
121 let offset = u32::from_le_bytes(buf.read_const::<4>());
122 let inner = super::super::br::Program::decode(buf.skip(offset as usize))?;
123 Program::BytecodeLt(inner)
124 }
125 _ => return Err(crate::Error::InvalidData),
126 })
127 }
128 }
129
130 #[allow(clippy::all, unused_variables)]
131 impl crate::Encode for ProgramType {
132 type HeadPtr = ProgramTypeHeadPtr;
133 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
134 let input = self.input.encode_head(buf);
135 let output = self.output.encode_head(buf);
136 let defs = self.defs.encode_head(buf);
137 ProgramTypeHeadPtr {
138 input,
139 output,
140 defs,
141 }
142 }
143 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
144 self.input.encode_body(head.input, buf);
145 self.output.encode_body(head.output, buf);
146 self.defs.encode_body(head.defs, buf);
147 }
148 }
149 #[allow(non_camel_case_types)]
150 pub struct ProgramTypeHeadPtr {
151 input: <super::super::ir::Ty as crate::Encode>::HeadPtr,
152 output: <super::super::ir::Ty as crate::Encode>::HeadPtr,
153 defs: <crate::vec::Vec<super::super::ir::TyDef> as crate::Encode>::HeadPtr,
154 }
155 impl crate::Layout for ProgramType {
156 fn head_size() -> usize {
157 432
158 }
159 }
160
161 impl crate::Decode for ProgramType {
162 fn decode(buf: &[u8]) -> crate::Result<Self> {
163 let input = super::super::ir::Ty::decode(buf.skip(0))?;
164 let output = super::super::ir::Ty::decode(buf.skip(23))?;
165 let defs = crate::vec::Vec::<super::super::ir::TyDef>::decode(buf.skip(46))?;
166 Ok(ProgramType {
167 input,
168 output,
169 defs,
170 })
171 }
172 }
173
174 #[allow(clippy::all, unused_variables)]
175 impl crate::Encode for SqlProgram {
176 type HeadPtr = SqlProgramHeadPtr;
177 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
178 let sql = self.sql.encode_head(buf);
179 let input_ty = self.input_ty.encode_head(buf);
180 let output_ty = self.output_ty.encode_head(buf);
181 let defs = self.defs.encode_head(buf);
182 SqlProgramHeadPtr {
183 sql,
184 input_ty,
185 output_ty,
186 defs,
187 }
188 }
189 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
190 self.sql.encode_body(head.sql, buf);
191 self.input_ty.encode_body(head.input_ty, buf);
192 self.output_ty.encode_body(head.output_ty, buf);
193 self.defs.encode_body(head.defs, buf);
194 }
195 }
196 #[allow(non_camel_case_types)]
197 pub struct SqlProgramHeadPtr {
198 sql: <crate::string::String as crate::Encode>::HeadPtr,
199 input_ty: <super::super::ir::Ty as crate::Encode>::HeadPtr,
200 output_ty: <super::super::ir::Ty as crate::Encode>::HeadPtr,
201 defs: <crate::vec::Vec<super::super::ir::TyDef> as crate::Encode>::HeadPtr,
202 }
203 impl crate::Layout for SqlProgram {
204 fn head_size() -> usize {
205 496
206 }
207 }
208
209 impl crate::Decode for SqlProgram {
210 fn decode(buf: &[u8]) -> crate::Result<Self> {
211 let sql = crate::string::String::decode(buf.skip(0))?;
212 let input_ty = super::super::ir::Ty::decode(buf.skip(8))?;
213 let output_ty = super::super::ir::Ty::decode(buf.skip(31))?;
214 let defs = crate::vec::Vec::<super::super::ir::TyDef>::decode(buf.skip(54))?;
215 Ok(SqlProgram {
216 sql,
217 input_ty,
218 output_ty,
219 defs,
220 })
221 }
222 }
223 }
224}
225
226pub mod layout {
227 #[derive(Debug, Clone)]
228 #[allow(non_camel_case_types)]
229 pub struct EnumFormat {
230 pub tag_bytes: u8,
231 pub inner_bytes: u8,
232 pub has_ptr: bool,
233 pub variants: crate::vec::Vec<EnumVariantFormat>,
234 }
235
236 #[derive(Debug, Clone)]
237 #[allow(non_camel_case_types)]
238 pub struct EnumVariantFormat {
239 pub is_unit: bool,
240 pub padding_bytes: u8,
241 }
242
243 mod impls {
244 #![allow(unused_imports)]
245 use super::*;
246 use crate::ReaderExt;
247 use crate::bytes::BufMut;
248
249 #[allow(clippy::all, unused_variables)]
250 impl crate::Encode for EnumFormat {
251 type HeadPtr = EnumFormatHeadPtr;
252 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
253 let tag_bytes = self.tag_bytes.encode_head(buf);
254 let inner_bytes = self.inner_bytes.encode_head(buf);
255 let has_ptr = self.has_ptr.encode_head(buf);
256 let variants = self.variants.encode_head(buf);
257 EnumFormatHeadPtr {
258 tag_bytes,
259 inner_bytes,
260 has_ptr,
261 variants,
262 }
263 }
264 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
265 self.tag_bytes.encode_body(head.tag_bytes, buf);
266 self.inner_bytes.encode_body(head.inner_bytes, buf);
267 self.has_ptr.encode_body(head.has_ptr, buf);
268 self.variants.encode_body(head.variants, buf);
269 }
270 }
271 #[allow(non_camel_case_types)]
272 pub struct EnumFormatHeadPtr {
273 tag_bytes: <u8 as crate::Encode>::HeadPtr,
274 inner_bytes: <u8 as crate::Encode>::HeadPtr,
275 has_ptr: <bool as crate::Encode>::HeadPtr,
276 variants: <crate::vec::Vec<super::EnumVariantFormat> as crate::Encode>::HeadPtr,
277 }
278 impl crate::Layout for EnumFormat {
279 fn head_size() -> usize {
280 88
281 }
282 }
283
284 impl crate::Decode for EnumFormat {
285 fn decode(buf: &[u8]) -> crate::Result<Self> {
286 let tag_bytes = u8::decode(buf.skip(0))?;
287 let inner_bytes = u8::decode(buf.skip(1))?;
288 let has_ptr = bool::decode(buf.skip(2))?;
289 let variants = crate::vec::Vec::<super::EnumVariantFormat>::decode(buf.skip(3))?;
290 Ok(EnumFormat {
291 tag_bytes,
292 inner_bytes,
293 has_ptr,
294 variants,
295 })
296 }
297 }
298
299 #[allow(clippy::all, unused_variables)]
300 impl crate::Encode for EnumVariantFormat {
301 type HeadPtr = EnumVariantFormatHeadPtr;
302 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
303 let is_unit = self.is_unit.encode_head(buf);
304 let padding_bytes = self.padding_bytes.encode_head(buf);
305 EnumVariantFormatHeadPtr {
306 is_unit,
307 padding_bytes,
308 }
309 }
310 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
311 self.is_unit.encode_body(head.is_unit, buf);
312 self.padding_bytes.encode_body(head.padding_bytes, buf);
313 }
314 }
315 #[allow(non_camel_case_types)]
316 pub struct EnumVariantFormatHeadPtr {
317 is_unit: <bool as crate::Encode>::HeadPtr,
318 padding_bytes: <u8 as crate::Encode>::HeadPtr,
319 }
320 impl crate::Layout for EnumVariantFormat {
321 fn head_size() -> usize {
322 16
323 }
324 }
325
326 impl crate::Decode for EnumVariantFormat {
327 fn decode(buf: &[u8]) -> crate::Result<Self> {
328 let is_unit = bool::decode(buf.skip(0))?;
329 let padding_bytes = u8::decode(buf.skip(1))?;
330 Ok(EnumVariantFormat {
331 is_unit,
332 padding_bytes,
333 })
334 }
335 }
336 }
337}
338
339pub mod ir {
340 #[derive(Debug, Clone)]
341 #[allow(non_camel_case_types)]
342 pub struct Program {
343 pub main: Expr,
344 pub defs: crate::vec::Vec<TyDef>,
345 }
346
347 #[derive(Debug, Clone)]
348 #[allow(non_camel_case_types)]
349 pub struct Expr {
350 pub kind: ExprKind,
351 pub ty: Ty,
352 }
353
354 #[derive(Debug, Clone, enum_as_inner::EnumAsInner)]
355 #[allow(non_camel_case_types)]
356 pub enum ExprKind {
357 Pointer(Pointer),
358 Literal(Literal),
359 Call(crate::boxed::Box<Call>),
360 Function(crate::boxed::Box<Function>),
361 Tuple(crate::vec::Vec<TupleField>),
362 Array(crate::vec::Vec<Expr>),
363 EnumVariant(crate::boxed::Box<EnumVariant>),
364 EnumTag(crate::boxed::Box<EnumTag>),
365 EnumUnwrap(crate::boxed::Box<EnumUnwrap>),
366 TupleLookup(crate::boxed::Box<TupleLookup>),
367 Binding(crate::boxed::Box<Binding>),
368 Switch(crate::vec::Vec<SwitchBranch>),
369 }
370
371 #[derive(Debug, Clone, enum_as_inner::EnumAsInner)]
372 #[allow(non_camel_case_types)]
373 pub enum Pointer {
374 External(ExternalPtr),
375 Binding(u32),
376 Parameter(ParameterPtr),
377 }
378
379 #[derive(Debug, Clone)]
380 #[allow(non_camel_case_types)]
381 pub struct ExternalPtr {
382 pub id: crate::string::String,
383 }
384
385 #[derive(Debug, Clone)]
386 #[allow(non_camel_case_types)]
387 pub struct ParameterPtr {
388 pub function_id: u32,
389 pub param_position: u8,
390 }
391
392 #[derive(Debug, Clone, PartialEq, enum_as_inner::EnumAsInner)]
393 #[allow(non_camel_case_types)]
394 pub enum Literal {
395 Prim8(u8),
396 Prim16(u16),
397 Prim32(u32),
398 Prim64(u64),
399 Text(crate::string::String),
400 }
401
402 #[derive(Debug, Clone)]
403 #[allow(non_camel_case_types)]
404 pub struct Call {
405 pub function: Expr,
406 pub args: crate::vec::Vec<Expr>,
407 }
408
409 #[derive(Debug, Clone)]
410 #[allow(non_camel_case_types)]
411 pub struct Function {
412 pub id: u32,
413 pub body: Expr,
414 }
415
416 #[derive(Debug, Clone)]
417 #[allow(non_camel_case_types)]
418 pub struct TupleField {
419 pub expr: Expr,
420 pub unpack: bool,
421 }
422
423 #[derive(Debug, Clone)]
424 #[allow(non_camel_case_types)]
425 pub struct EnumVariant {
426 pub tag: u64,
427 pub inner: Expr,
428 }
429
430 #[derive(Debug, Clone)]
431 #[allow(non_camel_case_types)]
432 pub struct EnumTag {
433 pub subject: Expr,
434 }
435
436 #[derive(Debug, Clone)]
437 #[allow(non_camel_case_types)]
438 pub struct EnumUnwrap {
439 pub subject: Expr,
440 pub tag: u64,
441 }
442
443 #[derive(Debug, Clone)]
444 #[allow(non_camel_case_types)]
445 pub struct TupleLookup {
446 pub base: Expr,
447 pub position: u16,
448 }
449
450 #[derive(Debug, Clone)]
451 #[allow(non_camel_case_types)]
452 pub struct Binding {
453 pub id: u32,
454 pub expr: Expr,
455 pub main: Expr,
456 }
457
458 #[derive(Debug, Clone)]
459 #[allow(non_camel_case_types)]
460 pub struct SwitchBranch {
461 pub condition: Expr,
462 pub value: Expr,
463 }
464
465 #[derive(Debug, Clone)]
466 #[allow(non_camel_case_types)]
467 pub struct TyDef {
468 pub name: Path,
469 pub ty: Ty,
470 }
471
472 #[derive(Debug, Clone)]
473 #[allow(non_camel_case_types)]
474 pub struct Ty {
475 pub kind: TyKind,
476 pub layout: core::option::Option<TyLayout>,
477 pub name: core::option::Option<crate::string::String>,
478 pub variants_recursive: crate::vec::Vec<u16>,
479 }
480
481 #[derive(Debug, Clone, PartialEq, enum_as_inner::EnumAsInner)]
482 #[allow(non_camel_case_types)]
483 pub enum TyKind {
484 Primitive(TyPrimitive),
485 Tuple(crate::vec::Vec<TyTupleField>),
486 Array(crate::boxed::Box<Ty>),
487 Enum(crate::vec::Vec<TyEnumVariant>),
488 Function(crate::boxed::Box<TyFunction>),
489 Ident(Path),
490 }
491
492 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
493 #[allow(non_camel_case_types)]
494 pub enum TyPrimitive {
495 Prim8,
496 Prim16,
497 Prim32,
498 Prim64,
499 }
500
501 #[derive(Debug, Clone, PartialEq)]
502 #[allow(non_camel_case_types)]
503 pub struct TyTupleField {
504 pub name: core::option::Option<crate::string::String>,
505 pub ty: Ty,
506 }
507
508 #[derive(Debug, Clone, PartialEq)]
509 #[allow(non_camel_case_types)]
510 pub struct TyEnumVariant {
511 pub name: crate::string::String,
512 pub ty: Ty,
513 }
514
515 #[derive(Debug, Clone, PartialEq, Default)]
516 #[allow(non_camel_case_types)]
517 pub struct TyLayout {
518 pub head_size: u32,
519 pub body_ptrs: crate::vec::Vec<u32>,
520 }
521
522 #[derive(Debug, Clone, PartialEq)]
523 #[allow(non_camel_case_types)]
524 pub struct TyFunction {
525 pub params: crate::vec::Vec<Ty>,
526 pub body: Ty,
527 }
528
529 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
530 #[allow(non_camel_case_types)]
531 pub struct Path(pub crate::vec::Vec<crate::string::String>);
532
533 #[derive(Debug, Clone)]
534 #[allow(non_camel_case_types)]
535 pub struct Module {
536 pub decls: crate::vec::Vec<ModuledeclsItems>,
537 }
538
539 #[derive(Debug, Clone)]
540 #[allow(non_camel_case_types)]
541 pub struct ModuledeclsItems {
542 pub name: crate::string::String,
543 pub decl: Decl,
544 }
545
546 #[derive(Debug, Clone)]
547 #[allow(non_camel_case_types)]
548 pub enum Decl {
549 Mod(crate::boxed::Box<Module>),
550 Ty(Ty),
551 Var(Ty),
552 }
553
554 mod impls {
555 #![allow(unused_imports)]
556 use super::*;
557 use crate::ReaderExt;
558 use crate::bytes::BufMut;
559
560 #[allow(clippy::all, unused_variables)]
561 impl crate::Encode for Program {
562 type HeadPtr = ProgramHeadPtr;
563 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
564 let main = self.main.encode_head(buf);
565 let defs = self.defs.encode_head(buf);
566 ProgramHeadPtr { main, defs }
567 }
568 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
569 self.main.encode_body(head.main, buf);
570 self.defs.encode_body(head.defs, buf);
571 }
572 }
573 #[allow(non_camel_case_types)]
574 pub struct ProgramHeadPtr {
575 main: <super::Expr as crate::Encode>::HeadPtr,
576 defs: <crate::vec::Vec<super::TyDef> as crate::Encode>::HeadPtr,
577 }
578 impl crate::Layout for Program {
579 fn head_size() -> usize {
580 288
581 }
582 }
583
584 impl crate::Decode for Program {
585 fn decode(buf: &[u8]) -> crate::Result<Self> {
586 let main = super::Expr::decode(buf.skip(0))?;
587 let defs = crate::vec::Vec::<super::TyDef>::decode(buf.skip(28))?;
588 Ok(Program { main, defs })
589 }
590 }
591
592 #[allow(clippy::all, unused_variables)]
593 impl crate::Encode for Expr {
594 type HeadPtr = ExprHeadPtr;
595 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
596 let kind = self.kind.encode_head(buf);
597 let ty = self.ty.encode_head(buf);
598 ExprHeadPtr { kind, ty }
599 }
600 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
601 self.kind.encode_body(head.kind, buf);
602 self.ty.encode_body(head.ty, buf);
603 }
604 }
605 #[allow(non_camel_case_types)]
606 pub struct ExprHeadPtr {
607 kind: <super::ExprKind as crate::Encode>::HeadPtr,
608 ty: <super::Ty as crate::Encode>::HeadPtr,
609 }
610 impl crate::Layout for Expr {
611 fn head_size() -> usize {
612 224
613 }
614 }
615
616 impl crate::Decode for Expr {
617 fn decode(buf: &[u8]) -> crate::Result<Self> {
618 let kind = super::ExprKind::decode(buf.skip(0))?;
619 let ty = super::Ty::decode(buf.skip(5))?;
620 Ok(Expr { kind, ty })
621 }
622 }
623
624 #[allow(unused_variables)]
625 #[allow(clippy::all)]
626 impl crate::Encode for ExprKind {
627 type HeadPtr = ExprKindHeadPtr;
628 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> ExprKindHeadPtr {
629 match self {
630 Self::Pointer(inner) => {
631 w.put_slice(&[0]);
632 let head_ptr = crate::ReversePointer::new(w);
633 let r = ExprKindHeadPtr::Pointer(head_ptr);
634 r
635 }
636 Self::Literal(inner) => {
637 w.put_slice(&[1]);
638 let head_ptr = crate::ReversePointer::new(w);
639 let r = ExprKindHeadPtr::Literal(head_ptr);
640 r
641 }
642 Self::Call(inner) => {
643 w.put_slice(&[2]);
644 let head_ptr = crate::ReversePointer::new(w);
645 let r = ExprKindHeadPtr::Call(head_ptr);
646 r
647 }
648 Self::Function(inner) => {
649 w.put_slice(&[3]);
650 let head_ptr = crate::ReversePointer::new(w);
651 let r = ExprKindHeadPtr::Function(head_ptr);
652 r
653 }
654 Self::Tuple(inner) => {
655 w.put_slice(&[4]);
656 let head_ptr = crate::ReversePointer::new(w);
657 let r = ExprKindHeadPtr::Tuple(head_ptr);
658 r
659 }
660 Self::Array(inner) => {
661 w.put_slice(&[5]);
662 let head_ptr = crate::ReversePointer::new(w);
663 let r = ExprKindHeadPtr::Array(head_ptr);
664 r
665 }
666 Self::EnumVariant(inner) => {
667 w.put_slice(&[6]);
668 let head_ptr = crate::ReversePointer::new(w);
669 let r = ExprKindHeadPtr::EnumVariant(head_ptr);
670 r
671 }
672 Self::EnumTag(inner) => {
673 w.put_slice(&[7]);
674 let head_ptr = crate::ReversePointer::new(w);
675 let r = ExprKindHeadPtr::EnumTag(head_ptr);
676 r
677 }
678 Self::EnumUnwrap(inner) => {
679 w.put_slice(&[8]);
680 let head_ptr = crate::ReversePointer::new(w);
681 let r = ExprKindHeadPtr::EnumUnwrap(head_ptr);
682 r
683 }
684 Self::TupleLookup(inner) => {
685 w.put_slice(&[9]);
686 let head_ptr = crate::ReversePointer::new(w);
687 let r = ExprKindHeadPtr::TupleLookup(head_ptr);
688 r
689 }
690 Self::Binding(inner) => {
691 w.put_slice(&[10]);
692 let head_ptr = crate::ReversePointer::new(w);
693 let r = ExprKindHeadPtr::Binding(head_ptr);
694 r
695 }
696 Self::Switch(inner) => {
697 w.put_slice(&[11]);
698 let head_ptr = crate::ReversePointer::new(w);
699 let r = ExprKindHeadPtr::Switch(head_ptr);
700 r
701 }
702 }
703 }
704 fn encode_body(&self, head: ExprKindHeadPtr, w: &mut crate::bytes::BytesMut) {
705 match self {
706 Self::Pointer(inner) => {
707 let ExprKindHeadPtr::Pointer(offset_ptr) = head else {
708 unreachable!()
709 };
710 offset_ptr.write_cur_len(w);
711 let inner_head_ptr = inner.encode_head(w);
712 inner.encode_body(inner_head_ptr, w);
713 }
714 Self::Literal(inner) => {
715 let ExprKindHeadPtr::Literal(offset_ptr) = head else {
716 unreachable!()
717 };
718 offset_ptr.write_cur_len(w);
719 let inner_head_ptr = inner.encode_head(w);
720 inner.encode_body(inner_head_ptr, w);
721 }
722 Self::Call(inner) => {
723 let ExprKindHeadPtr::Call(offset_ptr) = head else {
724 unreachable!()
725 };
726 offset_ptr.write_cur_len(w);
727 let inner_head_ptr = inner.encode_head(w);
728 inner.encode_body(inner_head_ptr, w);
729 }
730 Self::Function(inner) => {
731 let ExprKindHeadPtr::Function(offset_ptr) = head else {
732 unreachable!()
733 };
734 offset_ptr.write_cur_len(w);
735 let inner_head_ptr = inner.encode_head(w);
736 inner.encode_body(inner_head_ptr, w);
737 }
738 Self::Tuple(inner) => {
739 let ExprKindHeadPtr::Tuple(offset_ptr) = head else {
740 unreachable!()
741 };
742 offset_ptr.write_cur_len(w);
743 let inner_head_ptr = inner.encode_head(w);
744 inner.encode_body(inner_head_ptr, w);
745 }
746 Self::Array(inner) => {
747 let ExprKindHeadPtr::Array(offset_ptr) = head else {
748 unreachable!()
749 };
750 offset_ptr.write_cur_len(w);
751 let inner_head_ptr = inner.encode_head(w);
752 inner.encode_body(inner_head_ptr, w);
753 }
754 Self::EnumVariant(inner) => {
755 let ExprKindHeadPtr::EnumVariant(offset_ptr) = head else {
756 unreachable!()
757 };
758 offset_ptr.write_cur_len(w);
759 let inner_head_ptr = inner.encode_head(w);
760 inner.encode_body(inner_head_ptr, w);
761 }
762 Self::EnumTag(inner) => {
763 let ExprKindHeadPtr::EnumTag(offset_ptr) = head else {
764 unreachable!()
765 };
766 offset_ptr.write_cur_len(w);
767 let inner_head_ptr = inner.encode_head(w);
768 inner.encode_body(inner_head_ptr, w);
769 }
770 Self::EnumUnwrap(inner) => {
771 let ExprKindHeadPtr::EnumUnwrap(offset_ptr) = head else {
772 unreachable!()
773 };
774 offset_ptr.write_cur_len(w);
775 let inner_head_ptr = inner.encode_head(w);
776 inner.encode_body(inner_head_ptr, w);
777 }
778 Self::TupleLookup(inner) => {
779 let ExprKindHeadPtr::TupleLookup(offset_ptr) = head else {
780 unreachable!()
781 };
782 offset_ptr.write_cur_len(w);
783 let inner_head_ptr = inner.encode_head(w);
784 inner.encode_body(inner_head_ptr, w);
785 }
786 Self::Binding(inner) => {
787 let ExprKindHeadPtr::Binding(offset_ptr) = head else {
788 unreachable!()
789 };
790 offset_ptr.write_cur_len(w);
791 let inner_head_ptr = inner.encode_head(w);
792 inner.encode_body(inner_head_ptr, w);
793 }
794 Self::Switch(inner) => {
795 let ExprKindHeadPtr::Switch(offset_ptr) = head else {
796 unreachable!()
797 };
798 offset_ptr.write_cur_len(w);
799 let inner_head_ptr = inner.encode_head(w);
800 inner.encode_body(inner_head_ptr, w);
801 }
802 }
803 }
804 }
805 #[allow(non_camel_case_types, dead_code)]
806 pub enum ExprKindHeadPtr {
807 None,
808 Pointer(crate::ReversePointer),
809 Literal(crate::ReversePointer),
810 Call(crate::ReversePointer),
811 Function(crate::ReversePointer),
812 Tuple(crate::ReversePointer),
813 Array(crate::ReversePointer),
814 EnumVariant(crate::ReversePointer),
815 EnumTag(crate::ReversePointer),
816 EnumUnwrap(crate::ReversePointer),
817 TupleLookup(crate::ReversePointer),
818 Binding(crate::ReversePointer),
819 Switch(crate::ReversePointer),
820 }
821 impl crate::Layout for ExprKind {
822 fn head_size() -> usize {
823 40
824 }
825 }
826
827 impl crate::Decode for ExprKind {
828 fn decode(buf: &[u8]) -> crate::Result<Self> {
829 let mut tag_bytes = buf.read_n(1).to_vec();
830 tag_bytes.resize(8, 0);
831 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
832 let buf = buf.skip(1);
833 Ok(match tag {
834 0 => {
835 let offset = u32::from_le_bytes(buf.read_const::<4>());
836 let inner = super::Pointer::decode(buf.skip(offset as usize))?;
837 ExprKind::Pointer(inner)
838 }
839 1 => {
840 let offset = u32::from_le_bytes(buf.read_const::<4>());
841 let inner = super::Literal::decode(buf.skip(offset as usize))?;
842 ExprKind::Literal(inner)
843 }
844 2 => {
845 let offset = u32::from_le_bytes(buf.read_const::<4>());
846 let inner = super::Call::decode(buf.skip(offset as usize))?;
847 ExprKind::Call(crate::boxed::Box::new(inner))
848 }
849 3 => {
850 let offset = u32::from_le_bytes(buf.read_const::<4>());
851 let inner = super::Function::decode(buf.skip(offset as usize))?;
852 ExprKind::Function(crate::boxed::Box::new(inner))
853 }
854 4 => {
855 let offset = u32::from_le_bytes(buf.read_const::<4>());
856 let inner = crate::vec::Vec::<super::TupleField>::decode(
857 buf.skip(offset as usize),
858 )?;
859 ExprKind::Tuple(inner)
860 }
861 5 => {
862 let offset = u32::from_le_bytes(buf.read_const::<4>());
863 let inner =
864 crate::vec::Vec::<super::Expr>::decode(buf.skip(offset as usize))?;
865 ExprKind::Array(inner)
866 }
867 6 => {
868 let offset = u32::from_le_bytes(buf.read_const::<4>());
869 let inner = super::EnumVariant::decode(buf.skip(offset as usize))?;
870 ExprKind::EnumVariant(crate::boxed::Box::new(inner))
871 }
872 7 => {
873 let offset = u32::from_le_bytes(buf.read_const::<4>());
874 let inner = super::EnumTag::decode(buf.skip(offset as usize))?;
875 ExprKind::EnumTag(crate::boxed::Box::new(inner))
876 }
877 8 => {
878 let offset = u32::from_le_bytes(buf.read_const::<4>());
879 let inner = super::EnumUnwrap::decode(buf.skip(offset as usize))?;
880 ExprKind::EnumUnwrap(crate::boxed::Box::new(inner))
881 }
882 9 => {
883 let offset = u32::from_le_bytes(buf.read_const::<4>());
884 let inner = super::TupleLookup::decode(buf.skip(offset as usize))?;
885 ExprKind::TupleLookup(crate::boxed::Box::new(inner))
886 }
887 10 => {
888 let offset = u32::from_le_bytes(buf.read_const::<4>());
889 let inner = super::Binding::decode(buf.skip(offset as usize))?;
890 ExprKind::Binding(crate::boxed::Box::new(inner))
891 }
892 11 => {
893 let offset = u32::from_le_bytes(buf.read_const::<4>());
894 let inner = crate::vec::Vec::<super::SwitchBranch>::decode(
895 buf.skip(offset as usize),
896 )?;
897 ExprKind::Switch(inner)
898 }
899 _ => return Err(crate::Error::InvalidData),
900 })
901 }
902 }
903
904 #[allow(unused_variables)]
905 #[allow(clippy::all)]
906 impl crate::Encode for Pointer {
907 type HeadPtr = PointerHeadPtr;
908 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> PointerHeadPtr {
909 match self {
910 Self::External(inner) => {
911 w.put_slice(&[0]);
912 let head_ptr = crate::ReversePointer::new(w);
913 let r = PointerHeadPtr::External(head_ptr);
914 r
915 }
916 Self::Binding(inner) => {
917 w.put_slice(&[1]);
918 let head_ptr = crate::ReversePointer::new(w);
919 let r = PointerHeadPtr::Binding(head_ptr);
920 r
921 }
922 Self::Parameter(inner) => {
923 w.put_slice(&[2]);
924 let head_ptr = crate::ReversePointer::new(w);
925 let r = PointerHeadPtr::Parameter(head_ptr);
926 r
927 }
928 }
929 }
930 fn encode_body(&self, head: PointerHeadPtr, w: &mut crate::bytes::BytesMut) {
931 match self {
932 Self::External(inner) => {
933 let PointerHeadPtr::External(offset_ptr) = head else {
934 unreachable!()
935 };
936 offset_ptr.write_cur_len(w);
937 let inner_head_ptr = inner.encode_head(w);
938 inner.encode_body(inner_head_ptr, w);
939 }
940 Self::Binding(inner) => {
941 let PointerHeadPtr::Binding(offset_ptr) = head else {
942 unreachable!()
943 };
944 offset_ptr.write_cur_len(w);
945 let inner_head_ptr = inner.encode_head(w);
946 inner.encode_body(inner_head_ptr, w);
947 }
948 Self::Parameter(inner) => {
949 let PointerHeadPtr::Parameter(offset_ptr) = head else {
950 unreachable!()
951 };
952 offset_ptr.write_cur_len(w);
953 let inner_head_ptr = inner.encode_head(w);
954 inner.encode_body(inner_head_ptr, w);
955 }
956 }
957 }
958 }
959 #[allow(non_camel_case_types, dead_code)]
960 pub enum PointerHeadPtr {
961 None,
962 External(crate::ReversePointer),
963 Binding(crate::ReversePointer),
964 Parameter(crate::ReversePointer),
965 }
966 impl crate::Layout for Pointer {
967 fn head_size() -> usize {
968 40
969 }
970 }
971
972 impl crate::Decode for Pointer {
973 fn decode(buf: &[u8]) -> crate::Result<Self> {
974 let mut tag_bytes = buf.read_n(1).to_vec();
975 tag_bytes.resize(8, 0);
976 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
977 let buf = buf.skip(1);
978 Ok(match tag {
979 0 => {
980 let offset = u32::from_le_bytes(buf.read_const::<4>());
981 let inner = super::ExternalPtr::decode(buf.skip(offset as usize))?;
982 Pointer::External(inner)
983 }
984 1 => {
985 let offset = u32::from_le_bytes(buf.read_const::<4>());
986 let inner = u32::decode(buf.skip(offset as usize))?;
987 Pointer::Binding(inner)
988 }
989 2 => {
990 let offset = u32::from_le_bytes(buf.read_const::<4>());
991 let inner = super::ParameterPtr::decode(buf.skip(offset as usize))?;
992 Pointer::Parameter(inner)
993 }
994 _ => return Err(crate::Error::InvalidData),
995 })
996 }
997 }
998
999 #[allow(clippy::all, unused_variables)]
1000 impl crate::Encode for ExternalPtr {
1001 type HeadPtr = ExternalPtrHeadPtr;
1002 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1003 let id = self.id.encode_head(buf);
1004 ExternalPtrHeadPtr { id }
1005 }
1006 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1007 self.id.encode_body(head.id, buf);
1008 }
1009 }
1010 #[allow(non_camel_case_types)]
1011 pub struct ExternalPtrHeadPtr {
1012 id: <crate::string::String as crate::Encode>::HeadPtr,
1013 }
1014 impl crate::Layout for ExternalPtr {
1015 fn head_size() -> usize {
1016 64
1017 }
1018 }
1019
1020 impl crate::Decode for ExternalPtr {
1021 fn decode(buf: &[u8]) -> crate::Result<Self> {
1022 let id = crate::string::String::decode(buf.skip(0))?;
1023 Ok(ExternalPtr { id })
1024 }
1025 }
1026
1027 #[allow(clippy::all, unused_variables)]
1028 impl crate::Encode for ParameterPtr {
1029 type HeadPtr = ParameterPtrHeadPtr;
1030 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1031 let function_id = self.function_id.encode_head(buf);
1032 let param_position = self.param_position.encode_head(buf);
1033 ParameterPtrHeadPtr {
1034 function_id,
1035 param_position,
1036 }
1037 }
1038 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1039 self.function_id.encode_body(head.function_id, buf);
1040 self.param_position.encode_body(head.param_position, buf);
1041 }
1042 }
1043 #[allow(non_camel_case_types)]
1044 pub struct ParameterPtrHeadPtr {
1045 function_id: <u32 as crate::Encode>::HeadPtr,
1046 param_position: <u8 as crate::Encode>::HeadPtr,
1047 }
1048 impl crate::Layout for ParameterPtr {
1049 fn head_size() -> usize {
1050 40
1051 }
1052 }
1053
1054 impl crate::Decode for ParameterPtr {
1055 fn decode(buf: &[u8]) -> crate::Result<Self> {
1056 let function_id = u32::decode(buf.skip(0))?;
1057 let param_position = u8::decode(buf.skip(4))?;
1058 Ok(ParameterPtr {
1059 function_id,
1060 param_position,
1061 })
1062 }
1063 }
1064
1065 #[allow(unused_variables)]
1066 #[allow(clippy::all)]
1067 impl crate::Encode for Literal {
1068 type HeadPtr = LiteralHeadPtr;
1069 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> LiteralHeadPtr {
1070 match self {
1071 Self::Prim8(inner) => {
1072 w.put_slice(&[0]);
1073 let head_ptr = crate::ReversePointer::new(w);
1074 let r = LiteralHeadPtr::Prim8(head_ptr);
1075 r
1076 }
1077 Self::Prim16(inner) => {
1078 w.put_slice(&[1]);
1079 let head_ptr = crate::ReversePointer::new(w);
1080 let r = LiteralHeadPtr::Prim16(head_ptr);
1081 r
1082 }
1083 Self::Prim32(inner) => {
1084 w.put_slice(&[2]);
1085 let head_ptr = crate::ReversePointer::new(w);
1086 let r = LiteralHeadPtr::Prim32(head_ptr);
1087 r
1088 }
1089 Self::Prim64(inner) => {
1090 w.put_slice(&[3]);
1091 let head_ptr = crate::ReversePointer::new(w);
1092 let r = LiteralHeadPtr::Prim64(head_ptr);
1093 r
1094 }
1095 Self::Text(inner) => {
1096 w.put_slice(&[4]);
1097 let head_ptr = crate::ReversePointer::new(w);
1098 let r = LiteralHeadPtr::Text(head_ptr);
1099 r
1100 }
1101 }
1102 }
1103 fn encode_body(&self, head: LiteralHeadPtr, w: &mut crate::bytes::BytesMut) {
1104 match self {
1105 Self::Prim8(inner) => {
1106 let LiteralHeadPtr::Prim8(offset_ptr) = head else {
1107 unreachable!()
1108 };
1109 offset_ptr.write_cur_len(w);
1110 let inner_head_ptr = inner.encode_head(w);
1111 inner.encode_body(inner_head_ptr, w);
1112 }
1113 Self::Prim16(inner) => {
1114 let LiteralHeadPtr::Prim16(offset_ptr) = head else {
1115 unreachable!()
1116 };
1117 offset_ptr.write_cur_len(w);
1118 let inner_head_ptr = inner.encode_head(w);
1119 inner.encode_body(inner_head_ptr, w);
1120 }
1121 Self::Prim32(inner) => {
1122 let LiteralHeadPtr::Prim32(offset_ptr) = head else {
1123 unreachable!()
1124 };
1125 offset_ptr.write_cur_len(w);
1126 let inner_head_ptr = inner.encode_head(w);
1127 inner.encode_body(inner_head_ptr, w);
1128 }
1129 Self::Prim64(inner) => {
1130 let LiteralHeadPtr::Prim64(offset_ptr) = head else {
1131 unreachable!()
1132 };
1133 offset_ptr.write_cur_len(w);
1134 let inner_head_ptr = inner.encode_head(w);
1135 inner.encode_body(inner_head_ptr, w);
1136 }
1137 Self::Text(inner) => {
1138 let LiteralHeadPtr::Text(offset_ptr) = head else {
1139 unreachable!()
1140 };
1141 offset_ptr.write_cur_len(w);
1142 let inner_head_ptr = inner.encode_head(w);
1143 inner.encode_body(inner_head_ptr, w);
1144 }
1145 }
1146 }
1147 }
1148 #[allow(non_camel_case_types, dead_code)]
1149 pub enum LiteralHeadPtr {
1150 None,
1151 Prim8(crate::ReversePointer),
1152 Prim16(crate::ReversePointer),
1153 Prim32(crate::ReversePointer),
1154 Prim64(crate::ReversePointer),
1155 Text(crate::ReversePointer),
1156 }
1157 impl crate::Layout for Literal {
1158 fn head_size() -> usize {
1159 40
1160 }
1161 }
1162
1163 impl crate::Decode for Literal {
1164 fn decode(buf: &[u8]) -> crate::Result<Self> {
1165 let mut tag_bytes = buf.read_n(1).to_vec();
1166 tag_bytes.resize(8, 0);
1167 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1168 let buf = buf.skip(1);
1169 Ok(match tag {
1170 0 => {
1171 let offset = u32::from_le_bytes(buf.read_const::<4>());
1172 let inner = u8::decode(buf.skip(offset as usize))?;
1173 Literal::Prim8(inner)
1174 }
1175 1 => {
1176 let offset = u32::from_le_bytes(buf.read_const::<4>());
1177 let inner = u16::decode(buf.skip(offset as usize))?;
1178 Literal::Prim16(inner)
1179 }
1180 2 => {
1181 let offset = u32::from_le_bytes(buf.read_const::<4>());
1182 let inner = u32::decode(buf.skip(offset as usize))?;
1183 Literal::Prim32(inner)
1184 }
1185 3 => {
1186 let offset = u32::from_le_bytes(buf.read_const::<4>());
1187 let inner = u64::decode(buf.skip(offset as usize))?;
1188 Literal::Prim64(inner)
1189 }
1190 4 => {
1191 let offset = u32::from_le_bytes(buf.read_const::<4>());
1192 let inner = crate::string::String::decode(buf.skip(offset as usize))?;
1193 Literal::Text(inner)
1194 }
1195 _ => return Err(crate::Error::InvalidData),
1196 })
1197 }
1198 }
1199
1200 #[allow(clippy::all, unused_variables)]
1201 impl crate::Encode for Call {
1202 type HeadPtr = CallHeadPtr;
1203 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1204 let function = self.function.encode_head(buf);
1205 let args = self.args.encode_head(buf);
1206 CallHeadPtr { function, args }
1207 }
1208 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1209 self.function.encode_body(head.function, buf);
1210 self.args.encode_body(head.args, buf);
1211 }
1212 }
1213 #[allow(non_camel_case_types)]
1214 pub struct CallHeadPtr {
1215 function: <super::Expr as crate::Encode>::HeadPtr,
1216 args: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
1217 }
1218 impl crate::Layout for Call {
1219 fn head_size() -> usize {
1220 288
1221 }
1222 }
1223
1224 impl crate::Decode for Call {
1225 fn decode(buf: &[u8]) -> crate::Result<Self> {
1226 let function = super::Expr::decode(buf.skip(0))?;
1227 let args = crate::vec::Vec::<super::Expr>::decode(buf.skip(28))?;
1228 Ok(Call { function, args })
1229 }
1230 }
1231
1232 #[allow(clippy::all, unused_variables)]
1233 impl crate::Encode for Function {
1234 type HeadPtr = FunctionHeadPtr;
1235 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1236 let id = self.id.encode_head(buf);
1237 let body = self.body.encode_head(buf);
1238 FunctionHeadPtr { id, body }
1239 }
1240 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1241 self.id.encode_body(head.id, buf);
1242 self.body.encode_body(head.body, buf);
1243 }
1244 }
1245 #[allow(non_camel_case_types)]
1246 pub struct FunctionHeadPtr {
1247 id: <u32 as crate::Encode>::HeadPtr,
1248 body: <super::Expr as crate::Encode>::HeadPtr,
1249 }
1250 impl crate::Layout for Function {
1251 fn head_size() -> usize {
1252 256
1253 }
1254 }
1255
1256 impl crate::Decode for Function {
1257 fn decode(buf: &[u8]) -> crate::Result<Self> {
1258 let id = u32::decode(buf.skip(0))?;
1259 let body = super::Expr::decode(buf.skip(4))?;
1260 Ok(Function { id, body })
1261 }
1262 }
1263
1264 #[allow(clippy::all, unused_variables)]
1265 impl crate::Encode for TupleField {
1266 type HeadPtr = TupleFieldHeadPtr;
1267 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1268 let expr = self.expr.encode_head(buf);
1269 let unpack = self.unpack.encode_head(buf);
1270 TupleFieldHeadPtr { expr, unpack }
1271 }
1272 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1273 self.expr.encode_body(head.expr, buf);
1274 self.unpack.encode_body(head.unpack, buf);
1275 }
1276 }
1277 #[allow(non_camel_case_types)]
1278 pub struct TupleFieldHeadPtr {
1279 expr: <super::Expr as crate::Encode>::HeadPtr,
1280 unpack: <bool as crate::Encode>::HeadPtr,
1281 }
1282 impl crate::Layout for TupleField {
1283 fn head_size() -> usize {
1284 232
1285 }
1286 }
1287
1288 impl crate::Decode for TupleField {
1289 fn decode(buf: &[u8]) -> crate::Result<Self> {
1290 let expr = super::Expr::decode(buf.skip(0))?;
1291 let unpack = bool::decode(buf.skip(28))?;
1292 Ok(TupleField { expr, unpack })
1293 }
1294 }
1295
1296 #[allow(clippy::all, unused_variables)]
1297 impl crate::Encode for EnumVariant {
1298 type HeadPtr = EnumVariantHeadPtr;
1299 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1300 let tag = self.tag.encode_head(buf);
1301 let inner = self.inner.encode_head(buf);
1302 EnumVariantHeadPtr { tag, inner }
1303 }
1304 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1305 self.tag.encode_body(head.tag, buf);
1306 self.inner.encode_body(head.inner, buf);
1307 }
1308 }
1309 #[allow(non_camel_case_types)]
1310 pub struct EnumVariantHeadPtr {
1311 tag: <u64 as crate::Encode>::HeadPtr,
1312 inner: <super::Expr as crate::Encode>::HeadPtr,
1313 }
1314 impl crate::Layout for EnumVariant {
1315 fn head_size() -> usize {
1316 288
1317 }
1318 }
1319
1320 impl crate::Decode for EnumVariant {
1321 fn decode(buf: &[u8]) -> crate::Result<Self> {
1322 let tag = u64::decode(buf.skip(0))?;
1323 let inner = super::Expr::decode(buf.skip(8))?;
1324 Ok(EnumVariant { tag, inner })
1325 }
1326 }
1327
1328 #[allow(clippy::all, unused_variables)]
1329 impl crate::Encode for EnumTag {
1330 type HeadPtr = EnumTagHeadPtr;
1331 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1332 let subject = self.subject.encode_head(buf);
1333 EnumTagHeadPtr { subject }
1334 }
1335 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1336 self.subject.encode_body(head.subject, buf);
1337 }
1338 }
1339 #[allow(non_camel_case_types)]
1340 pub struct EnumTagHeadPtr {
1341 subject: <super::Expr as crate::Encode>::HeadPtr,
1342 }
1343 impl crate::Layout for EnumTag {
1344 fn head_size() -> usize {
1345 224
1346 }
1347 }
1348
1349 impl crate::Decode for EnumTag {
1350 fn decode(buf: &[u8]) -> crate::Result<Self> {
1351 let subject = super::Expr::decode(buf.skip(0))?;
1352 Ok(EnumTag { subject })
1353 }
1354 }
1355
1356 #[allow(clippy::all, unused_variables)]
1357 impl crate::Encode for EnumUnwrap {
1358 type HeadPtr = EnumUnwrapHeadPtr;
1359 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1360 let subject = self.subject.encode_head(buf);
1361 let tag = self.tag.encode_head(buf);
1362 EnumUnwrapHeadPtr { subject, tag }
1363 }
1364 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1365 self.subject.encode_body(head.subject, buf);
1366 self.tag.encode_body(head.tag, buf);
1367 }
1368 }
1369 #[allow(non_camel_case_types)]
1370 pub struct EnumUnwrapHeadPtr {
1371 subject: <super::Expr as crate::Encode>::HeadPtr,
1372 tag: <u64 as crate::Encode>::HeadPtr,
1373 }
1374 impl crate::Layout for EnumUnwrap {
1375 fn head_size() -> usize {
1376 288
1377 }
1378 }
1379
1380 impl crate::Decode for EnumUnwrap {
1381 fn decode(buf: &[u8]) -> crate::Result<Self> {
1382 let subject = super::Expr::decode(buf.skip(0))?;
1383 let tag = u64::decode(buf.skip(28))?;
1384 Ok(EnumUnwrap { subject, tag })
1385 }
1386 }
1387
1388 #[allow(clippy::all, unused_variables)]
1389 impl crate::Encode for TupleLookup {
1390 type HeadPtr = TupleLookupHeadPtr;
1391 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1392 let base = self.base.encode_head(buf);
1393 let position = self.position.encode_head(buf);
1394 TupleLookupHeadPtr { base, position }
1395 }
1396 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1397 self.base.encode_body(head.base, buf);
1398 self.position.encode_body(head.position, buf);
1399 }
1400 }
1401 #[allow(non_camel_case_types)]
1402 pub struct TupleLookupHeadPtr {
1403 base: <super::Expr as crate::Encode>::HeadPtr,
1404 position: <u16 as crate::Encode>::HeadPtr,
1405 }
1406 impl crate::Layout for TupleLookup {
1407 fn head_size() -> usize {
1408 240
1409 }
1410 }
1411
1412 impl crate::Decode for TupleLookup {
1413 fn decode(buf: &[u8]) -> crate::Result<Self> {
1414 let base = super::Expr::decode(buf.skip(0))?;
1415 let position = u16::decode(buf.skip(28))?;
1416 Ok(TupleLookup { base, position })
1417 }
1418 }
1419
1420 #[allow(clippy::all, unused_variables)]
1421 impl crate::Encode for Binding {
1422 type HeadPtr = BindingHeadPtr;
1423 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1424 let id = self.id.encode_head(buf);
1425 let expr = self.expr.encode_head(buf);
1426 let main = self.main.encode_head(buf);
1427 BindingHeadPtr { id, expr, main }
1428 }
1429 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1430 self.id.encode_body(head.id, buf);
1431 self.expr.encode_body(head.expr, buf);
1432 self.main.encode_body(head.main, buf);
1433 }
1434 }
1435 #[allow(non_camel_case_types)]
1436 pub struct BindingHeadPtr {
1437 id: <u32 as crate::Encode>::HeadPtr,
1438 expr: <super::Expr as crate::Encode>::HeadPtr,
1439 main: <super::Expr as crate::Encode>::HeadPtr,
1440 }
1441 impl crate::Layout for Binding {
1442 fn head_size() -> usize {
1443 480
1444 }
1445 }
1446
1447 impl crate::Decode for Binding {
1448 fn decode(buf: &[u8]) -> crate::Result<Self> {
1449 let id = u32::decode(buf.skip(0))?;
1450 let expr = super::Expr::decode(buf.skip(4))?;
1451 let main = super::Expr::decode(buf.skip(32))?;
1452 Ok(Binding { id, expr, main })
1453 }
1454 }
1455
1456 #[allow(clippy::all, unused_variables)]
1457 impl crate::Encode for SwitchBranch {
1458 type HeadPtr = SwitchBranchHeadPtr;
1459 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1460 let condition = self.condition.encode_head(buf);
1461 let value = self.value.encode_head(buf);
1462 SwitchBranchHeadPtr { condition, value }
1463 }
1464 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1465 self.condition.encode_body(head.condition, buf);
1466 self.value.encode_body(head.value, buf);
1467 }
1468 }
1469 #[allow(non_camel_case_types)]
1470 pub struct SwitchBranchHeadPtr {
1471 condition: <super::Expr as crate::Encode>::HeadPtr,
1472 value: <super::Expr as crate::Encode>::HeadPtr,
1473 }
1474 impl crate::Layout for SwitchBranch {
1475 fn head_size() -> usize {
1476 448
1477 }
1478 }
1479
1480 impl crate::Decode for SwitchBranch {
1481 fn decode(buf: &[u8]) -> crate::Result<Self> {
1482 let condition = super::Expr::decode(buf.skip(0))?;
1483 let value = super::Expr::decode(buf.skip(28))?;
1484 Ok(SwitchBranch { condition, value })
1485 }
1486 }
1487
1488 #[allow(clippy::all, unused_variables)]
1489 impl crate::Encode for TyDef {
1490 type HeadPtr = TyDefHeadPtr;
1491 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1492 let name = self.name.encode_head(buf);
1493 let ty = self.ty.encode_head(buf);
1494 TyDefHeadPtr { name, ty }
1495 }
1496 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1497 self.name.encode_body(head.name, buf);
1498 self.ty.encode_body(head.ty, buf);
1499 }
1500 }
1501 #[allow(non_camel_case_types)]
1502 pub struct TyDefHeadPtr {
1503 name: <super::Path as crate::Encode>::HeadPtr,
1504 ty: <super::Ty as crate::Encode>::HeadPtr,
1505 }
1506 impl crate::Layout for TyDef {
1507 fn head_size() -> usize {
1508 248
1509 }
1510 }
1511
1512 impl crate::Decode for TyDef {
1513 fn decode(buf: &[u8]) -> crate::Result<Self> {
1514 let name = super::Path::decode(buf.skip(0))?;
1515 let ty = super::Ty::decode(buf.skip(8))?;
1516 Ok(TyDef { name, ty })
1517 }
1518 }
1519
1520 #[allow(clippy::all, unused_variables)]
1521 impl crate::Encode for Ty {
1522 type HeadPtr = TyHeadPtr;
1523 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1524 let kind = self.kind.encode_head(buf);
1525 let layout = self.layout.encode_head(buf);
1526 let name = self.name.encode_head(buf);
1527 let variants_recursive = self.variants_recursive.encode_head(buf);
1528 TyHeadPtr {
1529 kind,
1530 layout,
1531 name,
1532 variants_recursive,
1533 }
1534 }
1535 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1536 self.kind.encode_body(head.kind, buf);
1537 self.layout.encode_body(head.layout, buf);
1538 self.name.encode_body(head.name, buf);
1539 self.variants_recursive
1540 .encode_body(head.variants_recursive, buf);
1541 }
1542 }
1543 #[allow(non_camel_case_types)]
1544 pub struct TyHeadPtr {
1545 kind: <super::TyKind as crate::Encode>::HeadPtr,
1546 layout: <core::option::Option<super::TyLayout> as crate::Encode>::HeadPtr,
1547 name: <core::option::Option<crate::string::String> as crate::Encode>::HeadPtr,
1548 variants_recursive: <crate::vec::Vec<u16> as crate::Encode>::HeadPtr,
1549 }
1550 impl crate::Layout for Ty {
1551 fn head_size() -> usize {
1552 184
1553 }
1554 }
1555
1556 impl crate::Decode for Ty {
1557 fn decode(buf: &[u8]) -> crate::Result<Self> {
1558 let kind = super::TyKind::decode(buf.skip(0))?;
1559 let layout = core::option::Option::<super::TyLayout>::decode(buf.skip(5))?;
1560 let name = core::option::Option::<crate::string::String>::decode(buf.skip(10))?;
1561 let variants_recursive = crate::vec::Vec::<u16>::decode(buf.skip(15))?;
1562 Ok(Ty {
1563 kind,
1564 layout,
1565 name,
1566 variants_recursive,
1567 })
1568 }
1569 }
1570
1571 #[allow(unused_variables)]
1572 #[allow(clippy::all)]
1573 impl crate::Encode for TyKind {
1574 type HeadPtr = TyKindHeadPtr;
1575 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> TyKindHeadPtr {
1576 match self {
1577 Self::Primitive(inner) => {
1578 w.put_slice(&[0]);
1579 let head_ptr = crate::ReversePointer::new(w);
1580 let r = TyKindHeadPtr::Primitive(head_ptr);
1581 r
1582 }
1583 Self::Tuple(inner) => {
1584 w.put_slice(&[1]);
1585 let head_ptr = crate::ReversePointer::new(w);
1586 let r = TyKindHeadPtr::Tuple(head_ptr);
1587 r
1588 }
1589 Self::Array(inner) => {
1590 w.put_slice(&[2]);
1591 let head_ptr = crate::ReversePointer::new(w);
1592 let r = TyKindHeadPtr::Array(head_ptr);
1593 r
1594 }
1595 Self::Enum(inner) => {
1596 w.put_slice(&[3]);
1597 let head_ptr = crate::ReversePointer::new(w);
1598 let r = TyKindHeadPtr::Enum(head_ptr);
1599 r
1600 }
1601 Self::Function(inner) => {
1602 w.put_slice(&[4]);
1603 let head_ptr = crate::ReversePointer::new(w);
1604 let r = TyKindHeadPtr::Function(head_ptr);
1605 r
1606 }
1607 Self::Ident(inner) => {
1608 w.put_slice(&[5]);
1609 let head_ptr = crate::ReversePointer::new(w);
1610 let r = TyKindHeadPtr::Ident(head_ptr);
1611 r
1612 }
1613 }
1614 }
1615 fn encode_body(&self, head: TyKindHeadPtr, w: &mut crate::bytes::BytesMut) {
1616 match self {
1617 Self::Primitive(inner) => {
1618 let TyKindHeadPtr::Primitive(offset_ptr) = head else {
1619 unreachable!()
1620 };
1621 offset_ptr.write_cur_len(w);
1622 let inner_head_ptr = inner.encode_head(w);
1623 inner.encode_body(inner_head_ptr, w);
1624 }
1625 Self::Tuple(inner) => {
1626 let TyKindHeadPtr::Tuple(offset_ptr) = head else {
1627 unreachable!()
1628 };
1629 offset_ptr.write_cur_len(w);
1630 let inner_head_ptr = inner.encode_head(w);
1631 inner.encode_body(inner_head_ptr, w);
1632 }
1633 Self::Array(inner) => {
1634 let TyKindHeadPtr::Array(offset_ptr) = head else {
1635 unreachable!()
1636 };
1637 offset_ptr.write_cur_len(w);
1638 let inner_head_ptr = inner.encode_head(w);
1639 inner.encode_body(inner_head_ptr, w);
1640 }
1641 Self::Enum(inner) => {
1642 let TyKindHeadPtr::Enum(offset_ptr) = head else {
1643 unreachable!()
1644 };
1645 offset_ptr.write_cur_len(w);
1646 let inner_head_ptr = inner.encode_head(w);
1647 inner.encode_body(inner_head_ptr, w);
1648 }
1649 Self::Function(inner) => {
1650 let TyKindHeadPtr::Function(offset_ptr) = head else {
1651 unreachable!()
1652 };
1653 offset_ptr.write_cur_len(w);
1654 let inner_head_ptr = inner.encode_head(w);
1655 inner.encode_body(inner_head_ptr, w);
1656 }
1657 Self::Ident(inner) => {
1658 let TyKindHeadPtr::Ident(offset_ptr) = head else {
1659 unreachable!()
1660 };
1661 offset_ptr.write_cur_len(w);
1662 let inner_head_ptr = inner.encode_head(w);
1663 inner.encode_body(inner_head_ptr, w);
1664 }
1665 }
1666 }
1667 }
1668 #[allow(non_camel_case_types, dead_code)]
1669 pub enum TyKindHeadPtr {
1670 None,
1671 Primitive(crate::ReversePointer),
1672 Tuple(crate::ReversePointer),
1673 Array(crate::ReversePointer),
1674 Enum(crate::ReversePointer),
1675 Function(crate::ReversePointer),
1676 Ident(crate::ReversePointer),
1677 }
1678 impl crate::Layout for TyKind {
1679 fn head_size() -> usize {
1680 40
1681 }
1682 }
1683
1684 impl crate::Decode for TyKind {
1685 fn decode(buf: &[u8]) -> crate::Result<Self> {
1686 let mut tag_bytes = buf.read_n(1).to_vec();
1687 tag_bytes.resize(8, 0);
1688 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1689 let buf = buf.skip(1);
1690 Ok(match tag {
1691 0 => {
1692 let offset = u32::from_le_bytes(buf.read_const::<4>());
1693 let inner = super::TyPrimitive::decode(buf.skip(offset as usize))?;
1694 TyKind::Primitive(inner)
1695 }
1696 1 => {
1697 let offset = u32::from_le_bytes(buf.read_const::<4>());
1698 let inner = crate::vec::Vec::<super::TyTupleField>::decode(
1699 buf.skip(offset as usize),
1700 )?;
1701 TyKind::Tuple(inner)
1702 }
1703 2 => {
1704 let offset = u32::from_le_bytes(buf.read_const::<4>());
1705 let inner = super::Ty::decode(buf.skip(offset as usize))?;
1706 TyKind::Array(crate::boxed::Box::new(inner))
1707 }
1708 3 => {
1709 let offset = u32::from_le_bytes(buf.read_const::<4>());
1710 let inner = crate::vec::Vec::<super::TyEnumVariant>::decode(
1711 buf.skip(offset as usize),
1712 )?;
1713 TyKind::Enum(inner)
1714 }
1715 4 => {
1716 let offset = u32::from_le_bytes(buf.read_const::<4>());
1717 let inner = super::TyFunction::decode(buf.skip(offset as usize))?;
1718 TyKind::Function(crate::boxed::Box::new(inner))
1719 }
1720 5 => {
1721 let offset = u32::from_le_bytes(buf.read_const::<4>());
1722 let inner = super::Path::decode(buf.skip(offset as usize))?;
1723 TyKind::Ident(inner)
1724 }
1725 _ => return Err(crate::Error::InvalidData),
1726 })
1727 }
1728 }
1729
1730 #[allow(unused_variables)]
1731 #[allow(clippy::all)]
1732 impl crate::Encode for TyPrimitive {
1733 type HeadPtr = ();
1734 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> () {
1735 match self {
1736 Self::Prim8 => {
1737 w.put_slice(&[0]);
1738 }
1739 Self::Prim16 => {
1740 w.put_slice(&[1]);
1741 }
1742 Self::Prim32 => {
1743 w.put_slice(&[2]);
1744 }
1745 Self::Prim64 => {
1746 w.put_slice(&[3]);
1747 }
1748 }
1749 }
1750 fn encode_body(&self, head: (), w: &mut crate::bytes::BytesMut) {}
1751 }
1752 impl crate::Layout for TyPrimitive {
1753 fn head_size() -> usize {
1754 8
1755 }
1756 }
1757
1758 impl crate::Decode for TyPrimitive {
1759 fn decode(buf: &[u8]) -> crate::Result<Self> {
1760 let mut tag_bytes = buf.read_n(1).to_vec();
1761 tag_bytes.resize(8, 0);
1762 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1763 Ok(match tag {
1764 0 => TyPrimitive::Prim8,
1765 1 => TyPrimitive::Prim16,
1766 2 => TyPrimitive::Prim32,
1767 3 => TyPrimitive::Prim64,
1768 _ => return Err(crate::Error::InvalidData),
1769 })
1770 }
1771 }
1772
1773 #[allow(clippy::all, unused_variables)]
1774 impl crate::Encode for TyTupleField {
1775 type HeadPtr = TyTupleFieldHeadPtr;
1776 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1777 let name = self.name.encode_head(buf);
1778 let ty = self.ty.encode_head(buf);
1779 TyTupleFieldHeadPtr { name, ty }
1780 }
1781 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1782 self.name.encode_body(head.name, buf);
1783 self.ty.encode_body(head.ty, buf);
1784 }
1785 }
1786 #[allow(non_camel_case_types)]
1787 pub struct TyTupleFieldHeadPtr {
1788 name: <core::option::Option<crate::string::String> as crate::Encode>::HeadPtr,
1789 ty: <super::Ty as crate::Encode>::HeadPtr,
1790 }
1791 impl crate::Layout for TyTupleField {
1792 fn head_size() -> usize {
1793 224
1794 }
1795 }
1796
1797 impl crate::Decode for TyTupleField {
1798 fn decode(buf: &[u8]) -> crate::Result<Self> {
1799 let name = core::option::Option::<crate::string::String>::decode(buf.skip(0))?;
1800 let ty = super::Ty::decode(buf.skip(5))?;
1801 Ok(TyTupleField { name, ty })
1802 }
1803 }
1804
1805 #[allow(clippy::all, unused_variables)]
1806 impl crate::Encode for TyEnumVariant {
1807 type HeadPtr = TyEnumVariantHeadPtr;
1808 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1809 let name = self.name.encode_head(buf);
1810 let ty = self.ty.encode_head(buf);
1811 TyEnumVariantHeadPtr { name, ty }
1812 }
1813 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1814 self.name.encode_body(head.name, buf);
1815 self.ty.encode_body(head.ty, buf);
1816 }
1817 }
1818 #[allow(non_camel_case_types)]
1819 pub struct TyEnumVariantHeadPtr {
1820 name: <crate::string::String as crate::Encode>::HeadPtr,
1821 ty: <super::Ty as crate::Encode>::HeadPtr,
1822 }
1823 impl crate::Layout for TyEnumVariant {
1824 fn head_size() -> usize {
1825 248
1826 }
1827 }
1828
1829 impl crate::Decode for TyEnumVariant {
1830 fn decode(buf: &[u8]) -> crate::Result<Self> {
1831 let name = crate::string::String::decode(buf.skip(0))?;
1832 let ty = super::Ty::decode(buf.skip(8))?;
1833 Ok(TyEnumVariant { name, ty })
1834 }
1835 }
1836
1837 #[allow(clippy::all, unused_variables)]
1838 impl crate::Encode for TyLayout {
1839 type HeadPtr = TyLayoutHeadPtr;
1840 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1841 let head_size = self.head_size.encode_head(buf);
1842 let body_ptrs = self.body_ptrs.encode_head(buf);
1843 TyLayoutHeadPtr {
1844 head_size,
1845 body_ptrs,
1846 }
1847 }
1848 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1849 self.head_size.encode_body(head.head_size, buf);
1850 self.body_ptrs.encode_body(head.body_ptrs, buf);
1851 }
1852 }
1853 #[allow(non_camel_case_types)]
1854 pub struct TyLayoutHeadPtr {
1855 head_size: <u32 as crate::Encode>::HeadPtr,
1856 body_ptrs: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
1857 }
1858 impl crate::Layout for TyLayout {
1859 fn head_size() -> usize {
1860 96
1861 }
1862 }
1863
1864 impl crate::Decode for TyLayout {
1865 fn decode(buf: &[u8]) -> crate::Result<Self> {
1866 let head_size = u32::decode(buf.skip(0))?;
1867 let body_ptrs = crate::vec::Vec::<u32>::decode(buf.skip(4))?;
1868 Ok(TyLayout {
1869 head_size,
1870 body_ptrs,
1871 })
1872 }
1873 }
1874
1875 #[allow(clippy::all, unused_variables)]
1876 impl crate::Encode for TyFunction {
1877 type HeadPtr = TyFunctionHeadPtr;
1878 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1879 let params = self.params.encode_head(buf);
1880 let body = self.body.encode_head(buf);
1881 TyFunctionHeadPtr { params, body }
1882 }
1883 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1884 self.params.encode_body(head.params, buf);
1885 self.body.encode_body(head.body, buf);
1886 }
1887 }
1888 #[allow(non_camel_case_types)]
1889 pub struct TyFunctionHeadPtr {
1890 params: <crate::vec::Vec<super::Ty> as crate::Encode>::HeadPtr,
1891 body: <super::Ty as crate::Encode>::HeadPtr,
1892 }
1893 impl crate::Layout for TyFunction {
1894 fn head_size() -> usize {
1895 248
1896 }
1897 }
1898
1899 impl crate::Decode for TyFunction {
1900 fn decode(buf: &[u8]) -> crate::Result<Self> {
1901 let params = crate::vec::Vec::<super::Ty>::decode(buf.skip(0))?;
1902 let body = super::Ty::decode(buf.skip(8))?;
1903 Ok(TyFunction { params, body })
1904 }
1905 }
1906
1907 impl crate::Encode for Path {
1908 type HeadPtr = crate::ReversePointer;
1909 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1910 self.0.encode_head(buf)
1911 }
1912 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1913 self.0.encode_body(head, buf)
1914 }
1915 }
1916 impl crate::Layout for Path {
1917 fn head_size() -> usize {
1918 64
1919 }
1920 }
1921
1922 impl crate::Decode for Path {
1923 fn decode(buf: &[u8]) -> crate::Result<Self> {
1924 Ok(Self(crate::vec::Vec::<crate::string::String>::decode(buf)?))
1925 }
1926 }
1927
1928 #[allow(clippy::all, unused_variables)]
1929 impl crate::Encode for Module {
1930 type HeadPtr = ModuleHeadPtr;
1931 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1932 let decls = self.decls.encode_head(buf);
1933 ModuleHeadPtr { decls }
1934 }
1935 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1936 self.decls.encode_body(head.decls, buf);
1937 }
1938 }
1939 #[allow(non_camel_case_types)]
1940 pub struct ModuleHeadPtr {
1941 decls: <crate::vec::Vec<ModuledeclsItems> as crate::Encode>::HeadPtr,
1942 }
1943 impl crate::Layout for Module {
1944 fn head_size() -> usize {
1945 64
1946 }
1947 }
1948
1949 impl crate::Decode for Module {
1950 fn decode(buf: &[u8]) -> crate::Result<Self> {
1951 let decls = crate::vec::Vec::<ModuledeclsItems>::decode(buf.skip(0))?;
1952 Ok(Module { decls })
1953 }
1954 }
1955
1956 #[allow(clippy::all, unused_variables)]
1957 impl crate::Encode for ModuledeclsItems {
1958 type HeadPtr = ModuledeclsItemsHeadPtr;
1959 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1960 let name = self.name.encode_head(buf);
1961 let decl = self.decl.encode_head(buf);
1962 ModuledeclsItemsHeadPtr { name, decl }
1963 }
1964 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1965 self.name.encode_body(head.name, buf);
1966 self.decl.encode_body(head.decl, buf);
1967 }
1968 }
1969 #[allow(non_camel_case_types)]
1970 pub struct ModuledeclsItemsHeadPtr {
1971 name: <crate::string::String as crate::Encode>::HeadPtr,
1972 decl: <super::Decl as crate::Encode>::HeadPtr,
1973 }
1974 impl crate::Layout for ModuledeclsItems {
1975 fn head_size() -> usize {
1976 104
1977 }
1978 }
1979
1980 impl crate::Decode for ModuledeclsItems {
1981 fn decode(buf: &[u8]) -> crate::Result<Self> {
1982 let name = crate::string::String::decode(buf.skip(0))?;
1983 let decl = super::Decl::decode(buf.skip(8))?;
1984 Ok(ModuledeclsItems { name, decl })
1985 }
1986 }
1987
1988 #[allow(unused_variables)]
1989 #[allow(clippy::all)]
1990 impl crate::Encode for Decl {
1991 type HeadPtr = DeclHeadPtr;
1992 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> DeclHeadPtr {
1993 match self {
1994 Self::Mod(inner) => {
1995 w.put_slice(&[0]);
1996 let head_ptr = crate::ReversePointer::new(w);
1997 let r = DeclHeadPtr::Mod(head_ptr);
1998 r
1999 }
2000 Self::Ty(inner) => {
2001 w.put_slice(&[1]);
2002 let head_ptr = crate::ReversePointer::new(w);
2003 let r = DeclHeadPtr::Ty(head_ptr);
2004 r
2005 }
2006 Self::Var(inner) => {
2007 w.put_slice(&[2]);
2008 let head_ptr = crate::ReversePointer::new(w);
2009 let r = DeclHeadPtr::Var(head_ptr);
2010 r
2011 }
2012 }
2013 }
2014 fn encode_body(&self, head: DeclHeadPtr, w: &mut crate::bytes::BytesMut) {
2015 match self {
2016 Self::Mod(inner) => {
2017 let DeclHeadPtr::Mod(offset_ptr) = head else {
2018 unreachable!()
2019 };
2020 offset_ptr.write_cur_len(w);
2021 let inner_head_ptr = inner.encode_head(w);
2022 inner.encode_body(inner_head_ptr, w);
2023 }
2024 Self::Ty(inner) => {
2025 let DeclHeadPtr::Ty(offset_ptr) = head else {
2026 unreachable!()
2027 };
2028 offset_ptr.write_cur_len(w);
2029 let inner_head_ptr = inner.encode_head(w);
2030 inner.encode_body(inner_head_ptr, w);
2031 }
2032 Self::Var(inner) => {
2033 let DeclHeadPtr::Var(offset_ptr) = head else {
2034 unreachable!()
2035 };
2036 offset_ptr.write_cur_len(w);
2037 let inner_head_ptr = inner.encode_head(w);
2038 inner.encode_body(inner_head_ptr, w);
2039 }
2040 }
2041 }
2042 }
2043 #[allow(non_camel_case_types, dead_code)]
2044 pub enum DeclHeadPtr {
2045 None,
2046 Mod(crate::ReversePointer),
2047 Ty(crate::ReversePointer),
2048 Var(crate::ReversePointer),
2049 }
2050 impl crate::Layout for Decl {
2051 fn head_size() -> usize {
2052 40
2053 }
2054 }
2055
2056 impl crate::Decode for Decl {
2057 fn decode(buf: &[u8]) -> crate::Result<Self> {
2058 let mut tag_bytes = buf.read_n(1).to_vec();
2059 tag_bytes.resize(8, 0);
2060 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
2061 let buf = buf.skip(1);
2062 Ok(match tag {
2063 0 => {
2064 let offset = u32::from_le_bytes(buf.read_const::<4>());
2065 let inner = super::Module::decode(buf.skip(offset as usize))?;
2066 Decl::Mod(crate::boxed::Box::new(inner))
2067 }
2068 1 => {
2069 let offset = u32::from_le_bytes(buf.read_const::<4>());
2070 let inner = super::Ty::decode(buf.skip(offset as usize))?;
2071 Decl::Ty(inner)
2072 }
2073 2 => {
2074 let offset = u32::from_le_bytes(buf.read_const::<4>());
2075 let inner = super::Ty::decode(buf.skip(offset as usize))?;
2076 Decl::Var(inner)
2077 }
2078 _ => return Err(crate::Error::InvalidData),
2079 })
2080 }
2081 }
2082 }
2083}
2084
2085pub mod br {
2086 #[derive(Debug, Clone)]
2087 #[allow(non_camel_case_types)]
2088 pub struct Program {
2089 pub externals: crate::vec::Vec<ExternalSymbol>,
2090 pub main: Expr,
2091 pub defs: crate::vec::Vec<super::ir::TyDef>,
2092 }
2093
2094 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
2095 #[allow(non_camel_case_types)]
2096 pub struct ExternalSymbol {
2097 pub id: crate::string::String,
2098 pub layout_args: crate::vec::Vec<u32>,
2099 }
2100
2101 #[derive(Debug, Clone)]
2102 #[allow(non_camel_case_types)]
2103 pub struct Expr {
2104 pub kind: ExprKind,
2105 }
2106
2107 #[derive(Debug, Clone, enum_as_inner::EnumAsInner)]
2108 #[allow(non_camel_case_types)]
2109 pub enum ExprKind {
2110 Pointer(Sid),
2111 Literal(crate::vec::Vec<u8>),
2112 Call(crate::boxed::Box<Call>),
2113 Function(crate::boxed::Box<Function>),
2114 Tuple(crate::boxed::Box<Tuple>),
2115 Array(crate::boxed::Box<Array>),
2116 EnumVariant(crate::boxed::Box<EnumVariant>),
2117 Offset(crate::boxed::Box<Offset>),
2118 Deref(crate::boxed::Box<Deref>),
2119 Binding(crate::boxed::Box<Binding>),
2120 Switch(crate::vec::Vec<SwitchBranch>),
2121 }
2122
2123 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
2124 #[allow(non_camel_case_types)]
2125 pub struct Sid(pub u32);
2126
2127 #[derive(Debug, Clone)]
2128 #[allow(non_camel_case_types)]
2129 pub struct Call {
2130 pub function: Expr,
2131 pub args: crate::vec::Vec<Expr>,
2132 }
2133
2134 #[derive(Debug, Clone)]
2135 #[allow(non_camel_case_types)]
2136 pub struct Function {
2137 pub symbol_ns: Sid,
2138 pub body: Expr,
2139 }
2140
2141 #[derive(Debug, Clone)]
2142 #[allow(non_camel_case_types)]
2143 pub struct Tuple {
2144 pub fields: crate::vec::Vec<TupleField>,
2145 pub field_layouts: crate::vec::Vec<TyLayout>,
2146 }
2147
2148 #[derive(Debug, Clone)]
2149 #[allow(non_camel_case_types)]
2150 pub struct TupleField {
2151 pub expr: Expr,
2152 pub unpack: u8,
2153 }
2154
2155 #[derive(Debug, Clone)]
2156 #[allow(non_camel_case_types)]
2157 pub struct Array {
2158 pub item_layout: TyLayout,
2159 pub items: crate::vec::Vec<Expr>,
2160 }
2161
2162 #[derive(Debug, Clone)]
2163 #[allow(non_camel_case_types)]
2164 pub struct EnumVariant {
2165 pub tag: crate::vec::Vec<u8>,
2166 pub inner_bytes: u8,
2167 pub has_ptr: bool,
2168 pub padding_bytes: u8,
2169 pub inner: Expr,
2170 }
2171
2172 #[derive(Debug, Clone)]
2173 #[allow(non_camel_case_types)]
2174 pub struct Offset {
2175 pub base: Expr,
2176 pub offset: u32,
2177 }
2178
2179 #[derive(Debug, Clone)]
2180 #[allow(non_camel_case_types)]
2181 pub struct Deref {
2182 pub ptr: Expr,
2183 }
2184
2185 #[derive(Debug, Clone)]
2186 #[allow(non_camel_case_types)]
2187 pub struct Binding {
2188 pub symbol: Sid,
2189 pub expr: Expr,
2190 pub main: Expr,
2191 }
2192
2193 #[derive(Debug, Clone)]
2194 #[allow(non_camel_case_types)]
2195 pub struct SwitchBranch {
2196 pub condition: Expr,
2197 pub value: Expr,
2198 }
2199
2200 #[derive(Debug, Clone, PartialEq, Default)]
2201 #[allow(non_camel_case_types)]
2202 pub struct TyLayout {
2203 pub head_size: u32,
2204 pub body_ptrs: crate::vec::Vec<u32>,
2205 }
2206
2207 mod impls {
2208 #![allow(unused_imports)]
2209 use super::*;
2210 use crate::ReaderExt;
2211 use crate::bytes::BufMut;
2212
2213 #[allow(clippy::all, unused_variables)]
2214 impl crate::Encode for Program {
2215 type HeadPtr = ProgramHeadPtr;
2216 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2217 let externals = self.externals.encode_head(buf);
2218 let main = self.main.encode_head(buf);
2219 let defs = self.defs.encode_head(buf);
2220 ProgramHeadPtr {
2221 externals,
2222 main,
2223 defs,
2224 }
2225 }
2226 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2227 self.externals.encode_body(head.externals, buf);
2228 self.main.encode_body(head.main, buf);
2229 self.defs.encode_body(head.defs, buf);
2230 }
2231 }
2232 #[allow(non_camel_case_types)]
2233 pub struct ProgramHeadPtr {
2234 externals: <crate::vec::Vec<super::ExternalSymbol> as crate::Encode>::HeadPtr,
2235 main: <super::Expr as crate::Encode>::HeadPtr,
2236 defs: <crate::vec::Vec<super::super::ir::TyDef> as crate::Encode>::HeadPtr,
2237 }
2238 impl crate::Layout for Program {
2239 fn head_size() -> usize {
2240 168
2241 }
2242 }
2243
2244 impl crate::Decode for Program {
2245 fn decode(buf: &[u8]) -> crate::Result<Self> {
2246 let externals = crate::vec::Vec::<super::ExternalSymbol>::decode(buf.skip(0))?;
2247 let main = super::Expr::decode(buf.skip(8))?;
2248 let defs = crate::vec::Vec::<super::super::ir::TyDef>::decode(buf.skip(13))?;
2249 Ok(Program {
2250 externals,
2251 main,
2252 defs,
2253 })
2254 }
2255 }
2256
2257 #[allow(clippy::all, unused_variables)]
2258 impl crate::Encode for ExternalSymbol {
2259 type HeadPtr = ExternalSymbolHeadPtr;
2260 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2261 let id = self.id.encode_head(buf);
2262 let layout_args = self.layout_args.encode_head(buf);
2263 ExternalSymbolHeadPtr { id, layout_args }
2264 }
2265 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2266 self.id.encode_body(head.id, buf);
2267 self.layout_args.encode_body(head.layout_args, buf);
2268 }
2269 }
2270 #[allow(non_camel_case_types)]
2271 pub struct ExternalSymbolHeadPtr {
2272 id: <crate::string::String as crate::Encode>::HeadPtr,
2273 layout_args: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
2274 }
2275 impl crate::Layout for ExternalSymbol {
2276 fn head_size() -> usize {
2277 128
2278 }
2279 }
2280
2281 impl crate::Decode for ExternalSymbol {
2282 fn decode(buf: &[u8]) -> crate::Result<Self> {
2283 let id = crate::string::String::decode(buf.skip(0))?;
2284 let layout_args = crate::vec::Vec::<u32>::decode(buf.skip(8))?;
2285 Ok(ExternalSymbol { id, layout_args })
2286 }
2287 }
2288
2289 #[allow(clippy::all, unused_variables)]
2290 impl crate::Encode for Expr {
2291 type HeadPtr = ExprHeadPtr;
2292 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2293 let kind = self.kind.encode_head(buf);
2294 ExprHeadPtr { kind }
2295 }
2296 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2297 self.kind.encode_body(head.kind, buf);
2298 }
2299 }
2300 #[allow(non_camel_case_types)]
2301 pub struct ExprHeadPtr {
2302 kind: <super::ExprKind as crate::Encode>::HeadPtr,
2303 }
2304 impl crate::Layout for Expr {
2305 fn head_size() -> usize {
2306 40
2307 }
2308 }
2309
2310 impl crate::Decode for Expr {
2311 fn decode(buf: &[u8]) -> crate::Result<Self> {
2312 let kind = super::ExprKind::decode(buf.skip(0))?;
2313 Ok(Expr { kind })
2314 }
2315 }
2316
2317 #[allow(unused_variables)]
2318 #[allow(clippy::all)]
2319 impl crate::Encode for ExprKind {
2320 type HeadPtr = ExprKindHeadPtr;
2321 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> ExprKindHeadPtr {
2322 match self {
2323 Self::Pointer(inner) => {
2324 w.put_slice(&[0]);
2325 let head_ptr = crate::ReversePointer::new(w);
2326 let r = ExprKindHeadPtr::Pointer(head_ptr);
2327 r
2328 }
2329 Self::Literal(inner) => {
2330 w.put_slice(&[1]);
2331 let head_ptr = crate::ReversePointer::new(w);
2332 let r = ExprKindHeadPtr::Literal(head_ptr);
2333 r
2334 }
2335 Self::Call(inner) => {
2336 w.put_slice(&[2]);
2337 let head_ptr = crate::ReversePointer::new(w);
2338 let r = ExprKindHeadPtr::Call(head_ptr);
2339 r
2340 }
2341 Self::Function(inner) => {
2342 w.put_slice(&[3]);
2343 let head_ptr = crate::ReversePointer::new(w);
2344 let r = ExprKindHeadPtr::Function(head_ptr);
2345 r
2346 }
2347 Self::Tuple(inner) => {
2348 w.put_slice(&[4]);
2349 let head_ptr = crate::ReversePointer::new(w);
2350 let r = ExprKindHeadPtr::Tuple(head_ptr);
2351 r
2352 }
2353 Self::Array(inner) => {
2354 w.put_slice(&[5]);
2355 let head_ptr = crate::ReversePointer::new(w);
2356 let r = ExprKindHeadPtr::Array(head_ptr);
2357 r
2358 }
2359 Self::EnumVariant(inner) => {
2360 w.put_slice(&[6]);
2361 let head_ptr = crate::ReversePointer::new(w);
2362 let r = ExprKindHeadPtr::EnumVariant(head_ptr);
2363 r
2364 }
2365 Self::Offset(inner) => {
2366 w.put_slice(&[7]);
2367 let head_ptr = crate::ReversePointer::new(w);
2368 let r = ExprKindHeadPtr::Offset(head_ptr);
2369 r
2370 }
2371 Self::Deref(inner) => {
2372 w.put_slice(&[8]);
2373 let head_ptr = crate::ReversePointer::new(w);
2374 let r = ExprKindHeadPtr::Deref(head_ptr);
2375 r
2376 }
2377 Self::Binding(inner) => {
2378 w.put_slice(&[9]);
2379 let head_ptr = crate::ReversePointer::new(w);
2380 let r = ExprKindHeadPtr::Binding(head_ptr);
2381 r
2382 }
2383 Self::Switch(inner) => {
2384 w.put_slice(&[10]);
2385 let head_ptr = crate::ReversePointer::new(w);
2386 let r = ExprKindHeadPtr::Switch(head_ptr);
2387 r
2388 }
2389 }
2390 }
2391 fn encode_body(&self, head: ExprKindHeadPtr, w: &mut crate::bytes::BytesMut) {
2392 match self {
2393 Self::Pointer(inner) => {
2394 let ExprKindHeadPtr::Pointer(offset_ptr) = head else {
2395 unreachable!()
2396 };
2397 offset_ptr.write_cur_len(w);
2398 let inner_head_ptr = inner.encode_head(w);
2399 inner.encode_body(inner_head_ptr, w);
2400 }
2401 Self::Literal(inner) => {
2402 let ExprKindHeadPtr::Literal(offset_ptr) = head else {
2403 unreachable!()
2404 };
2405 offset_ptr.write_cur_len(w);
2406 let inner_head_ptr = inner.encode_head(w);
2407 inner.encode_body(inner_head_ptr, w);
2408 }
2409 Self::Call(inner) => {
2410 let ExprKindHeadPtr::Call(offset_ptr) = head else {
2411 unreachable!()
2412 };
2413 offset_ptr.write_cur_len(w);
2414 let inner_head_ptr = inner.encode_head(w);
2415 inner.encode_body(inner_head_ptr, w);
2416 }
2417 Self::Function(inner) => {
2418 let ExprKindHeadPtr::Function(offset_ptr) = head else {
2419 unreachable!()
2420 };
2421 offset_ptr.write_cur_len(w);
2422 let inner_head_ptr = inner.encode_head(w);
2423 inner.encode_body(inner_head_ptr, w);
2424 }
2425 Self::Tuple(inner) => {
2426 let ExprKindHeadPtr::Tuple(offset_ptr) = head else {
2427 unreachable!()
2428 };
2429 offset_ptr.write_cur_len(w);
2430 let inner_head_ptr = inner.encode_head(w);
2431 inner.encode_body(inner_head_ptr, w);
2432 }
2433 Self::Array(inner) => {
2434 let ExprKindHeadPtr::Array(offset_ptr) = head else {
2435 unreachable!()
2436 };
2437 offset_ptr.write_cur_len(w);
2438 let inner_head_ptr = inner.encode_head(w);
2439 inner.encode_body(inner_head_ptr, w);
2440 }
2441 Self::EnumVariant(inner) => {
2442 let ExprKindHeadPtr::EnumVariant(offset_ptr) = head else {
2443 unreachable!()
2444 };
2445 offset_ptr.write_cur_len(w);
2446 let inner_head_ptr = inner.encode_head(w);
2447 inner.encode_body(inner_head_ptr, w);
2448 }
2449 Self::Offset(inner) => {
2450 let ExprKindHeadPtr::Offset(offset_ptr) = head else {
2451 unreachable!()
2452 };
2453 offset_ptr.write_cur_len(w);
2454 let inner_head_ptr = inner.encode_head(w);
2455 inner.encode_body(inner_head_ptr, w);
2456 }
2457 Self::Deref(inner) => {
2458 let ExprKindHeadPtr::Deref(offset_ptr) = head else {
2459 unreachable!()
2460 };
2461 offset_ptr.write_cur_len(w);
2462 let inner_head_ptr = inner.encode_head(w);
2463 inner.encode_body(inner_head_ptr, w);
2464 }
2465 Self::Binding(inner) => {
2466 let ExprKindHeadPtr::Binding(offset_ptr) = head else {
2467 unreachable!()
2468 };
2469 offset_ptr.write_cur_len(w);
2470 let inner_head_ptr = inner.encode_head(w);
2471 inner.encode_body(inner_head_ptr, w);
2472 }
2473 Self::Switch(inner) => {
2474 let ExprKindHeadPtr::Switch(offset_ptr) = head else {
2475 unreachable!()
2476 };
2477 offset_ptr.write_cur_len(w);
2478 let inner_head_ptr = inner.encode_head(w);
2479 inner.encode_body(inner_head_ptr, w);
2480 }
2481 }
2482 }
2483 }
2484 #[allow(non_camel_case_types, dead_code)]
2485 pub enum ExprKindHeadPtr {
2486 None,
2487 Pointer(crate::ReversePointer),
2488 Literal(crate::ReversePointer),
2489 Call(crate::ReversePointer),
2490 Function(crate::ReversePointer),
2491 Tuple(crate::ReversePointer),
2492 Array(crate::ReversePointer),
2493 EnumVariant(crate::ReversePointer),
2494 Offset(crate::ReversePointer),
2495 Deref(crate::ReversePointer),
2496 Binding(crate::ReversePointer),
2497 Switch(crate::ReversePointer),
2498 }
2499 impl crate::Layout for ExprKind {
2500 fn head_size() -> usize {
2501 40
2502 }
2503 }
2504
2505 impl crate::Decode for ExprKind {
2506 fn decode(buf: &[u8]) -> crate::Result<Self> {
2507 let mut tag_bytes = buf.read_n(1).to_vec();
2508 tag_bytes.resize(8, 0);
2509 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
2510 let buf = buf.skip(1);
2511 Ok(match tag {
2512 0 => {
2513 let offset = u32::from_le_bytes(buf.read_const::<4>());
2514 let inner = super::Sid::decode(buf.skip(offset as usize))?;
2515 ExprKind::Pointer(inner)
2516 }
2517 1 => {
2518 let offset = u32::from_le_bytes(buf.read_const::<4>());
2519 let inner = crate::vec::Vec::<u8>::decode(buf.skip(offset as usize))?;
2520 ExprKind::Literal(inner)
2521 }
2522 2 => {
2523 let offset = u32::from_le_bytes(buf.read_const::<4>());
2524 let inner = super::Call::decode(buf.skip(offset as usize))?;
2525 ExprKind::Call(crate::boxed::Box::new(inner))
2526 }
2527 3 => {
2528 let offset = u32::from_le_bytes(buf.read_const::<4>());
2529 let inner = super::Function::decode(buf.skip(offset as usize))?;
2530 ExprKind::Function(crate::boxed::Box::new(inner))
2531 }
2532 4 => {
2533 let offset = u32::from_le_bytes(buf.read_const::<4>());
2534 let inner = super::Tuple::decode(buf.skip(offset as usize))?;
2535 ExprKind::Tuple(crate::boxed::Box::new(inner))
2536 }
2537 5 => {
2538 let offset = u32::from_le_bytes(buf.read_const::<4>());
2539 let inner = super::Array::decode(buf.skip(offset as usize))?;
2540 ExprKind::Array(crate::boxed::Box::new(inner))
2541 }
2542 6 => {
2543 let offset = u32::from_le_bytes(buf.read_const::<4>());
2544 let inner = super::EnumVariant::decode(buf.skip(offset as usize))?;
2545 ExprKind::EnumVariant(crate::boxed::Box::new(inner))
2546 }
2547 7 => {
2548 let offset = u32::from_le_bytes(buf.read_const::<4>());
2549 let inner = super::Offset::decode(buf.skip(offset as usize))?;
2550 ExprKind::Offset(crate::boxed::Box::new(inner))
2551 }
2552 8 => {
2553 let offset = u32::from_le_bytes(buf.read_const::<4>());
2554 let inner = super::Deref::decode(buf.skip(offset as usize))?;
2555 ExprKind::Deref(crate::boxed::Box::new(inner))
2556 }
2557 9 => {
2558 let offset = u32::from_le_bytes(buf.read_const::<4>());
2559 let inner = super::Binding::decode(buf.skip(offset as usize))?;
2560 ExprKind::Binding(crate::boxed::Box::new(inner))
2561 }
2562 10 => {
2563 let offset = u32::from_le_bytes(buf.read_const::<4>());
2564 let inner = crate::vec::Vec::<super::SwitchBranch>::decode(
2565 buf.skip(offset as usize),
2566 )?;
2567 ExprKind::Switch(inner)
2568 }
2569 _ => return Err(crate::Error::InvalidData),
2570 })
2571 }
2572 }
2573
2574 impl crate::Encode for Sid {
2575 type HeadPtr = ();
2576 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) {
2577 self.0.encode_head(buf)
2578 }
2579 fn encode_body(&self, _: (), _: &mut crate::bytes::BytesMut) {}
2580 }
2581 impl crate::Layout for Sid {
2582 fn head_size() -> usize {
2583 32
2584 }
2585 }
2586
2587 impl crate::Decode for Sid {
2588 fn decode(buf: &[u8]) -> crate::Result<Self> {
2589 Ok(Self(u32::decode(buf)?))
2590 }
2591 }
2592
2593 #[allow(clippy::all, unused_variables)]
2594 impl crate::Encode for Call {
2595 type HeadPtr = CallHeadPtr;
2596 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2597 let function = self.function.encode_head(buf);
2598 let args = self.args.encode_head(buf);
2599 CallHeadPtr { function, args }
2600 }
2601 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2602 self.function.encode_body(head.function, buf);
2603 self.args.encode_body(head.args, buf);
2604 }
2605 }
2606 #[allow(non_camel_case_types)]
2607 pub struct CallHeadPtr {
2608 function: <super::Expr as crate::Encode>::HeadPtr,
2609 args: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
2610 }
2611 impl crate::Layout for Call {
2612 fn head_size() -> usize {
2613 104
2614 }
2615 }
2616
2617 impl crate::Decode for Call {
2618 fn decode(buf: &[u8]) -> crate::Result<Self> {
2619 let function = super::Expr::decode(buf.skip(0))?;
2620 let args = crate::vec::Vec::<super::Expr>::decode(buf.skip(5))?;
2621 Ok(Call { function, args })
2622 }
2623 }
2624
2625 #[allow(clippy::all, unused_variables)]
2626 impl crate::Encode for Function {
2627 type HeadPtr = FunctionHeadPtr;
2628 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2629 let symbol_ns = self.symbol_ns.encode_head(buf);
2630 let body = self.body.encode_head(buf);
2631 FunctionHeadPtr { symbol_ns, body }
2632 }
2633 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2634 self.symbol_ns.encode_body(head.symbol_ns, buf);
2635 self.body.encode_body(head.body, buf);
2636 }
2637 }
2638 #[allow(non_camel_case_types)]
2639 pub struct FunctionHeadPtr {
2640 symbol_ns: <super::Sid as crate::Encode>::HeadPtr,
2641 body: <super::Expr as crate::Encode>::HeadPtr,
2642 }
2643 impl crate::Layout for Function {
2644 fn head_size() -> usize {
2645 72
2646 }
2647 }
2648
2649 impl crate::Decode for Function {
2650 fn decode(buf: &[u8]) -> crate::Result<Self> {
2651 let symbol_ns = super::Sid::decode(buf.skip(0))?;
2652 let body = super::Expr::decode(buf.skip(4))?;
2653 Ok(Function { symbol_ns, body })
2654 }
2655 }
2656
2657 #[allow(clippy::all, unused_variables)]
2658 impl crate::Encode for Tuple {
2659 type HeadPtr = TupleHeadPtr;
2660 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2661 let fields = self.fields.encode_head(buf);
2662 let field_layouts = self.field_layouts.encode_head(buf);
2663 TupleHeadPtr {
2664 fields,
2665 field_layouts,
2666 }
2667 }
2668 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2669 self.fields.encode_body(head.fields, buf);
2670 self.field_layouts.encode_body(head.field_layouts, buf);
2671 }
2672 }
2673 #[allow(non_camel_case_types)]
2674 pub struct TupleHeadPtr {
2675 fields: <crate::vec::Vec<super::TupleField> as crate::Encode>::HeadPtr,
2676 field_layouts: <crate::vec::Vec<super::TyLayout> as crate::Encode>::HeadPtr,
2677 }
2678 impl crate::Layout for Tuple {
2679 fn head_size() -> usize {
2680 128
2681 }
2682 }
2683
2684 impl crate::Decode for Tuple {
2685 fn decode(buf: &[u8]) -> crate::Result<Self> {
2686 let fields = crate::vec::Vec::<super::TupleField>::decode(buf.skip(0))?;
2687 let field_layouts = crate::vec::Vec::<super::TyLayout>::decode(buf.skip(8))?;
2688 Ok(Tuple {
2689 fields,
2690 field_layouts,
2691 })
2692 }
2693 }
2694
2695 #[allow(clippy::all, unused_variables)]
2696 impl crate::Encode for TupleField {
2697 type HeadPtr = TupleFieldHeadPtr;
2698 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2699 let expr = self.expr.encode_head(buf);
2700 let unpack = self.unpack.encode_head(buf);
2701 TupleFieldHeadPtr { expr, unpack }
2702 }
2703 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2704 self.expr.encode_body(head.expr, buf);
2705 self.unpack.encode_body(head.unpack, buf);
2706 }
2707 }
2708 #[allow(non_camel_case_types)]
2709 pub struct TupleFieldHeadPtr {
2710 expr: <super::Expr as crate::Encode>::HeadPtr,
2711 unpack: <u8 as crate::Encode>::HeadPtr,
2712 }
2713 impl crate::Layout for TupleField {
2714 fn head_size() -> usize {
2715 48
2716 }
2717 }
2718
2719 impl crate::Decode for TupleField {
2720 fn decode(buf: &[u8]) -> crate::Result<Self> {
2721 let expr = super::Expr::decode(buf.skip(0))?;
2722 let unpack = u8::decode(buf.skip(5))?;
2723 Ok(TupleField { expr, unpack })
2724 }
2725 }
2726
2727 #[allow(clippy::all, unused_variables)]
2728 impl crate::Encode for Array {
2729 type HeadPtr = ArrayHeadPtr;
2730 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2731 let item_layout = self.item_layout.encode_head(buf);
2732 let items = self.items.encode_head(buf);
2733 ArrayHeadPtr { item_layout, items }
2734 }
2735 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2736 self.item_layout.encode_body(head.item_layout, buf);
2737 self.items.encode_body(head.items, buf);
2738 }
2739 }
2740 #[allow(non_camel_case_types)]
2741 pub struct ArrayHeadPtr {
2742 item_layout: <super::TyLayout as crate::Encode>::HeadPtr,
2743 items: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
2744 }
2745 impl crate::Layout for Array {
2746 fn head_size() -> usize {
2747 160
2748 }
2749 }
2750
2751 impl crate::Decode for Array {
2752 fn decode(buf: &[u8]) -> crate::Result<Self> {
2753 let item_layout = super::TyLayout::decode(buf.skip(0))?;
2754 let items = crate::vec::Vec::<super::Expr>::decode(buf.skip(12))?;
2755 Ok(Array { item_layout, items })
2756 }
2757 }
2758
2759 #[allow(clippy::all, unused_variables)]
2760 impl crate::Encode for EnumVariant {
2761 type HeadPtr = EnumVariantHeadPtr;
2762 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2763 let tag = self.tag.encode_head(buf);
2764 let inner_bytes = self.inner_bytes.encode_head(buf);
2765 let has_ptr = self.has_ptr.encode_head(buf);
2766 let padding_bytes = self.padding_bytes.encode_head(buf);
2767 let inner = self.inner.encode_head(buf);
2768 EnumVariantHeadPtr {
2769 tag,
2770 inner_bytes,
2771 has_ptr,
2772 padding_bytes,
2773 inner,
2774 }
2775 }
2776 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2777 self.tag.encode_body(head.tag, buf);
2778 self.inner_bytes.encode_body(head.inner_bytes, buf);
2779 self.has_ptr.encode_body(head.has_ptr, buf);
2780 self.padding_bytes.encode_body(head.padding_bytes, buf);
2781 self.inner.encode_body(head.inner, buf);
2782 }
2783 }
2784 #[allow(non_camel_case_types)]
2785 pub struct EnumVariantHeadPtr {
2786 tag: <crate::vec::Vec<u8> as crate::Encode>::HeadPtr,
2787 inner_bytes: <u8 as crate::Encode>::HeadPtr,
2788 has_ptr: <bool as crate::Encode>::HeadPtr,
2789 padding_bytes: <u8 as crate::Encode>::HeadPtr,
2790 inner: <super::Expr as crate::Encode>::HeadPtr,
2791 }
2792 impl crate::Layout for EnumVariant {
2793 fn head_size() -> usize {
2794 128
2795 }
2796 }
2797
2798 impl crate::Decode for EnumVariant {
2799 fn decode(buf: &[u8]) -> crate::Result<Self> {
2800 let tag = crate::vec::Vec::<u8>::decode(buf.skip(0))?;
2801 let inner_bytes = u8::decode(buf.skip(8))?;
2802 let has_ptr = bool::decode(buf.skip(9))?;
2803 let padding_bytes = u8::decode(buf.skip(10))?;
2804 let inner = super::Expr::decode(buf.skip(11))?;
2805 Ok(EnumVariant {
2806 tag,
2807 inner_bytes,
2808 has_ptr,
2809 padding_bytes,
2810 inner,
2811 })
2812 }
2813 }
2814
2815 #[allow(clippy::all, unused_variables)]
2816 impl crate::Encode for Offset {
2817 type HeadPtr = OffsetHeadPtr;
2818 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2819 let base = self.base.encode_head(buf);
2820 let offset = self.offset.encode_head(buf);
2821 OffsetHeadPtr { base, offset }
2822 }
2823 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2824 self.base.encode_body(head.base, buf);
2825 self.offset.encode_body(head.offset, buf);
2826 }
2827 }
2828 #[allow(non_camel_case_types)]
2829 pub struct OffsetHeadPtr {
2830 base: <super::Expr as crate::Encode>::HeadPtr,
2831 offset: <u32 as crate::Encode>::HeadPtr,
2832 }
2833 impl crate::Layout for Offset {
2834 fn head_size() -> usize {
2835 72
2836 }
2837 }
2838
2839 impl crate::Decode for Offset {
2840 fn decode(buf: &[u8]) -> crate::Result<Self> {
2841 let base = super::Expr::decode(buf.skip(0))?;
2842 let offset = u32::decode(buf.skip(5))?;
2843 Ok(Offset { base, offset })
2844 }
2845 }
2846
2847 #[allow(clippy::all, unused_variables)]
2848 impl crate::Encode for Deref {
2849 type HeadPtr = DerefHeadPtr;
2850 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2851 let ptr = self.ptr.encode_head(buf);
2852 DerefHeadPtr { ptr }
2853 }
2854 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2855 self.ptr.encode_body(head.ptr, buf);
2856 }
2857 }
2858 #[allow(non_camel_case_types)]
2859 pub struct DerefHeadPtr {
2860 ptr: <super::Expr as crate::Encode>::HeadPtr,
2861 }
2862 impl crate::Layout for Deref {
2863 fn head_size() -> usize {
2864 40
2865 }
2866 }
2867
2868 impl crate::Decode for Deref {
2869 fn decode(buf: &[u8]) -> crate::Result<Self> {
2870 let ptr = super::Expr::decode(buf.skip(0))?;
2871 Ok(Deref { ptr })
2872 }
2873 }
2874
2875 #[allow(clippy::all, unused_variables)]
2876 impl crate::Encode for Binding {
2877 type HeadPtr = BindingHeadPtr;
2878 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2879 let symbol = self.symbol.encode_head(buf);
2880 let expr = self.expr.encode_head(buf);
2881 let main = self.main.encode_head(buf);
2882 BindingHeadPtr { symbol, expr, main }
2883 }
2884 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2885 self.symbol.encode_body(head.symbol, buf);
2886 self.expr.encode_body(head.expr, buf);
2887 self.main.encode_body(head.main, buf);
2888 }
2889 }
2890 #[allow(non_camel_case_types)]
2891 pub struct BindingHeadPtr {
2892 symbol: <super::Sid as crate::Encode>::HeadPtr,
2893 expr: <super::Expr as crate::Encode>::HeadPtr,
2894 main: <super::Expr as crate::Encode>::HeadPtr,
2895 }
2896 impl crate::Layout for Binding {
2897 fn head_size() -> usize {
2898 112
2899 }
2900 }
2901
2902 impl crate::Decode for Binding {
2903 fn decode(buf: &[u8]) -> crate::Result<Self> {
2904 let symbol = super::Sid::decode(buf.skip(0))?;
2905 let expr = super::Expr::decode(buf.skip(4))?;
2906 let main = super::Expr::decode(buf.skip(9))?;
2907 Ok(Binding { symbol, expr, main })
2908 }
2909 }
2910
2911 #[allow(clippy::all, unused_variables)]
2912 impl crate::Encode for SwitchBranch {
2913 type HeadPtr = SwitchBranchHeadPtr;
2914 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2915 let condition = self.condition.encode_head(buf);
2916 let value = self.value.encode_head(buf);
2917 SwitchBranchHeadPtr { condition, value }
2918 }
2919 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2920 self.condition.encode_body(head.condition, buf);
2921 self.value.encode_body(head.value, buf);
2922 }
2923 }
2924 #[allow(non_camel_case_types)]
2925 pub struct SwitchBranchHeadPtr {
2926 condition: <super::Expr as crate::Encode>::HeadPtr,
2927 value: <super::Expr as crate::Encode>::HeadPtr,
2928 }
2929 impl crate::Layout for SwitchBranch {
2930 fn head_size() -> usize {
2931 80
2932 }
2933 }
2934
2935 impl crate::Decode for SwitchBranch {
2936 fn decode(buf: &[u8]) -> crate::Result<Self> {
2937 let condition = super::Expr::decode(buf.skip(0))?;
2938 let value = super::Expr::decode(buf.skip(5))?;
2939 Ok(SwitchBranch { condition, value })
2940 }
2941 }
2942
2943 #[allow(clippy::all, unused_variables)]
2944 impl crate::Encode for TyLayout {
2945 type HeadPtr = TyLayoutHeadPtr;
2946 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2947 let head_size = self.head_size.encode_head(buf);
2948 let body_ptrs = self.body_ptrs.encode_head(buf);
2949 TyLayoutHeadPtr {
2950 head_size,
2951 body_ptrs,
2952 }
2953 }
2954 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2955 self.head_size.encode_body(head.head_size, buf);
2956 self.body_ptrs.encode_body(head.body_ptrs, buf);
2957 }
2958 }
2959 #[allow(non_camel_case_types)]
2960 pub struct TyLayoutHeadPtr {
2961 head_size: <u32 as crate::Encode>::HeadPtr,
2962 body_ptrs: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
2963 }
2964 impl crate::Layout for TyLayout {
2965 fn head_size() -> usize {
2966 96
2967 }
2968 }
2969
2970 impl crate::Decode for TyLayout {
2971 fn decode(buf: &[u8]) -> crate::Result<Self> {
2972 let head_size = u32::decode(buf.skip(0))?;
2973 let body_ptrs = crate::vec::Vec::<u32>::decode(buf.skip(4))?;
2974 Ok(TyLayout {
2975 head_size,
2976 body_ptrs,
2977 })
2978 }
2979 }
2980 }
2981}