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 EnumEq(crate::boxed::Box<EnumEq>),
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 bool(bool),
396 int8(i8),
397 int16(i16),
398 int32(i32),
399 int64(i64),
400 uint8(u8),
401 uint16(u16),
402 uint32(u32),
403 uint64(u64),
404 float32(f32),
405 float64(f64),
406 text(crate::string::String),
407 }
408
409 #[derive(Debug, Clone)]
410 #[allow(non_camel_case_types)]
411 pub struct Call {
412 pub function: Expr,
413 pub args: crate::vec::Vec<Expr>,
414 }
415
416 #[derive(Debug, Clone)]
417 #[allow(non_camel_case_types)]
418 pub struct Function {
419 pub id: u32,
420 pub body: Expr,
421 }
422
423 #[derive(Debug, Clone)]
424 #[allow(non_camel_case_types)]
425 pub struct TupleField {
426 pub expr: Expr,
427 pub unpack: bool,
428 }
429
430 #[derive(Debug, Clone)]
431 #[allow(non_camel_case_types)]
432 pub struct EnumVariant {
433 pub tag: u64,
434 pub inner: Expr,
435 }
436
437 #[derive(Debug, Clone)]
438 #[allow(non_camel_case_types)]
439 pub struct EnumEq {
440 pub subject: Expr,
441 pub tag: u64,
442 }
443
444 #[derive(Debug, Clone)]
445 #[allow(non_camel_case_types)]
446 pub struct EnumUnwrap {
447 pub subject: Expr,
448 pub tag: u64,
449 }
450
451 #[derive(Debug, Clone)]
452 #[allow(non_camel_case_types)]
453 pub struct TupleLookup {
454 pub base: Expr,
455 pub position: u16,
456 }
457
458 #[derive(Debug, Clone)]
459 #[allow(non_camel_case_types)]
460 pub struct Binding {
461 pub id: u32,
462 pub expr: Expr,
463 pub main: Expr,
464 }
465
466 #[derive(Debug, Clone)]
467 #[allow(non_camel_case_types)]
468 pub struct SwitchBranch {
469 pub condition: Expr,
470 pub value: Expr,
471 }
472
473 #[derive(Debug, Clone)]
474 #[allow(non_camel_case_types)]
475 pub struct TyDef {
476 pub name: Path,
477 pub ty: Ty,
478 }
479
480 #[derive(Debug, Clone)]
481 #[allow(non_camel_case_types)]
482 pub struct Ty {
483 pub kind: TyKind,
484 pub layout: core::option::Option<TyLayout>,
485 pub name: core::option::Option<crate::string::String>,
486 pub variants_recursive: crate::vec::Vec<u16>,
487 }
488
489 #[derive(Debug, Clone, PartialEq, enum_as_inner::EnumAsInner)]
490 #[allow(non_camel_case_types)]
491 pub enum TyKind {
492 Primitive(TyPrimitive),
493 Tuple(crate::vec::Vec<TyTupleField>),
494 Array(crate::boxed::Box<Ty>),
495 Enum(crate::vec::Vec<TyEnumVariant>),
496 Function(crate::boxed::Box<TyFunction>),
497 Ident(Path),
498 }
499
500 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
501 #[allow(non_camel_case_types)]
502 pub enum TyPrimitive {
503 bool,
504 int8,
505 int16,
506 int32,
507 int64,
508 uint8,
509 uint16,
510 uint32,
511 uint64,
512 float32,
513 float64,
514 text,
515 }
516
517 #[derive(Debug, Clone, PartialEq)]
518 #[allow(non_camel_case_types)]
519 pub struct TyTupleField {
520 pub name: core::option::Option<crate::string::String>,
521 pub ty: Ty,
522 }
523
524 #[derive(Debug, Clone, PartialEq)]
525 #[allow(non_camel_case_types)]
526 pub struct TyEnumVariant {
527 pub name: crate::string::String,
528 pub ty: Ty,
529 }
530
531 #[derive(Debug, Clone, PartialEq, Default)]
532 #[allow(non_camel_case_types)]
533 pub struct TyLayout {
534 pub head_size: u32,
535 pub body_ptrs: crate::vec::Vec<u32>,
536 }
537
538 #[derive(Debug, Clone, PartialEq)]
539 #[allow(non_camel_case_types)]
540 pub struct TyFunction {
541 pub params: crate::vec::Vec<Ty>,
542 pub body: Ty,
543 }
544
545 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
546 #[allow(non_camel_case_types)]
547 pub struct Path(pub crate::vec::Vec<crate::string::String>);
548
549 #[derive(Debug, Clone)]
550 #[allow(non_camel_case_types)]
551 pub struct Module {
552 pub decls: crate::vec::Vec<ModuledeclsItems>,
553 }
554
555 #[derive(Debug, Clone)]
556 #[allow(non_camel_case_types)]
557 pub struct ModuledeclsItems {
558 pub name: crate::string::String,
559 pub decl: Decl,
560 }
561
562 #[derive(Debug, Clone)]
563 #[allow(non_camel_case_types)]
564 pub enum Decl {
565 Module(crate::boxed::Box<Module>),
566 Type(Ty),
567 Var(Ty),
568 }
569
570 mod impls {
571 #![allow(unused_imports)]
572 use super::*;
573 use crate::ReaderExt;
574 use crate::bytes::BufMut;
575
576 #[allow(clippy::all, unused_variables)]
577 impl crate::Encode for Program {
578 type HeadPtr = ProgramHeadPtr;
579 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
580 let main = self.main.encode_head(buf);
581 let defs = self.defs.encode_head(buf);
582 ProgramHeadPtr { main, defs }
583 }
584 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
585 self.main.encode_body(head.main, buf);
586 self.defs.encode_body(head.defs, buf);
587 }
588 }
589 #[allow(non_camel_case_types)]
590 pub struct ProgramHeadPtr {
591 main: <super::Expr as crate::Encode>::HeadPtr,
592 defs: <crate::vec::Vec<super::TyDef> as crate::Encode>::HeadPtr,
593 }
594 impl crate::Layout for Program {
595 fn head_size() -> usize {
596 288
597 }
598 }
599
600 impl crate::Decode for Program {
601 fn decode(buf: &[u8]) -> crate::Result<Self> {
602 let main = super::Expr::decode(buf.skip(0))?;
603 let defs = crate::vec::Vec::<super::TyDef>::decode(buf.skip(28))?;
604 Ok(Program { main, defs })
605 }
606 }
607
608 #[allow(clippy::all, unused_variables)]
609 impl crate::Encode for Expr {
610 type HeadPtr = ExprHeadPtr;
611 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
612 let kind = self.kind.encode_head(buf);
613 let ty = self.ty.encode_head(buf);
614 ExprHeadPtr { kind, ty }
615 }
616 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
617 self.kind.encode_body(head.kind, buf);
618 self.ty.encode_body(head.ty, buf);
619 }
620 }
621 #[allow(non_camel_case_types)]
622 pub struct ExprHeadPtr {
623 kind: <super::ExprKind as crate::Encode>::HeadPtr,
624 ty: <super::Ty as crate::Encode>::HeadPtr,
625 }
626 impl crate::Layout for Expr {
627 fn head_size() -> usize {
628 224
629 }
630 }
631
632 impl crate::Decode for Expr {
633 fn decode(buf: &[u8]) -> crate::Result<Self> {
634 let kind = super::ExprKind::decode(buf.skip(0))?;
635 let ty = super::Ty::decode(buf.skip(5))?;
636 Ok(Expr { kind, ty })
637 }
638 }
639
640 #[allow(unused_variables)]
641 #[allow(clippy::all)]
642 impl crate::Encode for ExprKind {
643 type HeadPtr = ExprKindHeadPtr;
644 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> ExprKindHeadPtr {
645 match self {
646 Self::Pointer(inner) => {
647 w.put_slice(&[0]);
648 let head_ptr = crate::ReversePointer::new(w);
649 let r = ExprKindHeadPtr::Pointer(head_ptr);
650 r
651 }
652 Self::Literal(inner) => {
653 w.put_slice(&[1]);
654 let head_ptr = crate::ReversePointer::new(w);
655 let r = ExprKindHeadPtr::Literal(head_ptr);
656 r
657 }
658 Self::Call(inner) => {
659 w.put_slice(&[2]);
660 let head_ptr = crate::ReversePointer::new(w);
661 let r = ExprKindHeadPtr::Call(head_ptr);
662 r
663 }
664 Self::Function(inner) => {
665 w.put_slice(&[3]);
666 let head_ptr = crate::ReversePointer::new(w);
667 let r = ExprKindHeadPtr::Function(head_ptr);
668 r
669 }
670 Self::Tuple(inner) => {
671 w.put_slice(&[4]);
672 let head_ptr = crate::ReversePointer::new(w);
673 let r = ExprKindHeadPtr::Tuple(head_ptr);
674 r
675 }
676 Self::Array(inner) => {
677 w.put_slice(&[5]);
678 let head_ptr = crate::ReversePointer::new(w);
679 let r = ExprKindHeadPtr::Array(head_ptr);
680 r
681 }
682 Self::EnumVariant(inner) => {
683 w.put_slice(&[6]);
684 let head_ptr = crate::ReversePointer::new(w);
685 let r = ExprKindHeadPtr::EnumVariant(head_ptr);
686 r
687 }
688 Self::EnumEq(inner) => {
689 w.put_slice(&[7]);
690 let head_ptr = crate::ReversePointer::new(w);
691 let r = ExprKindHeadPtr::EnumEq(head_ptr);
692 r
693 }
694 Self::EnumUnwrap(inner) => {
695 w.put_slice(&[8]);
696 let head_ptr = crate::ReversePointer::new(w);
697 let r = ExprKindHeadPtr::EnumUnwrap(head_ptr);
698 r
699 }
700 Self::TupleLookup(inner) => {
701 w.put_slice(&[9]);
702 let head_ptr = crate::ReversePointer::new(w);
703 let r = ExprKindHeadPtr::TupleLookup(head_ptr);
704 r
705 }
706 Self::Binding(inner) => {
707 w.put_slice(&[10]);
708 let head_ptr = crate::ReversePointer::new(w);
709 let r = ExprKindHeadPtr::Binding(head_ptr);
710 r
711 }
712 Self::Switch(inner) => {
713 w.put_slice(&[11]);
714 let head_ptr = crate::ReversePointer::new(w);
715 let r = ExprKindHeadPtr::Switch(head_ptr);
716 r
717 }
718 }
719 }
720 fn encode_body(&self, head: ExprKindHeadPtr, w: &mut crate::bytes::BytesMut) {
721 match self {
722 Self::Pointer(inner) => {
723 let ExprKindHeadPtr::Pointer(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::Literal(inner) => {
731 let ExprKindHeadPtr::Literal(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::Call(inner) => {
739 let ExprKindHeadPtr::Call(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::Function(inner) => {
747 let ExprKindHeadPtr::Function(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::Tuple(inner) => {
755 let ExprKindHeadPtr::Tuple(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::Array(inner) => {
763 let ExprKindHeadPtr::Array(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::EnumVariant(inner) => {
771 let ExprKindHeadPtr::EnumVariant(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::EnumEq(inner) => {
779 let ExprKindHeadPtr::EnumEq(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::EnumUnwrap(inner) => {
787 let ExprKindHeadPtr::EnumUnwrap(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::TupleLookup(inner) => {
795 let ExprKindHeadPtr::TupleLookup(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 Self::Binding(inner) => {
803 let ExprKindHeadPtr::Binding(offset_ptr) = head else {
804 unreachable!()
805 };
806 offset_ptr.write_cur_len(w);
807 let inner_head_ptr = inner.encode_head(w);
808 inner.encode_body(inner_head_ptr, w);
809 }
810 Self::Switch(inner) => {
811 let ExprKindHeadPtr::Switch(offset_ptr) = head else {
812 unreachable!()
813 };
814 offset_ptr.write_cur_len(w);
815 let inner_head_ptr = inner.encode_head(w);
816 inner.encode_body(inner_head_ptr, w);
817 }
818 }
819 }
820 }
821 #[allow(non_camel_case_types, dead_code)]
822 pub enum ExprKindHeadPtr {
823 None,
824 Pointer(crate::ReversePointer),
825 Literal(crate::ReversePointer),
826 Call(crate::ReversePointer),
827 Function(crate::ReversePointer),
828 Tuple(crate::ReversePointer),
829 Array(crate::ReversePointer),
830 EnumVariant(crate::ReversePointer),
831 EnumEq(crate::ReversePointer),
832 EnumUnwrap(crate::ReversePointer),
833 TupleLookup(crate::ReversePointer),
834 Binding(crate::ReversePointer),
835 Switch(crate::ReversePointer),
836 }
837 impl crate::Layout for ExprKind {
838 fn head_size() -> usize {
839 40
840 }
841 }
842
843 impl crate::Decode for ExprKind {
844 fn decode(buf: &[u8]) -> crate::Result<Self> {
845 let mut tag_bytes = buf.read_n(1).to_vec();
846 tag_bytes.resize(8, 0);
847 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
848 let buf = buf.skip(1);
849 Ok(match tag {
850 0 => {
851 let offset = u32::from_le_bytes(buf.read_const::<4>());
852 let inner = super::Pointer::decode(buf.skip(offset as usize))?;
853 ExprKind::Pointer(inner)
854 }
855 1 => {
856 let offset = u32::from_le_bytes(buf.read_const::<4>());
857 let inner = super::Literal::decode(buf.skip(offset as usize))?;
858 ExprKind::Literal(inner)
859 }
860 2 => {
861 let offset = u32::from_le_bytes(buf.read_const::<4>());
862 let inner = super::Call::decode(buf.skip(offset as usize))?;
863 ExprKind::Call(crate::boxed::Box::new(inner))
864 }
865 3 => {
866 let offset = u32::from_le_bytes(buf.read_const::<4>());
867 let inner = super::Function::decode(buf.skip(offset as usize))?;
868 ExprKind::Function(crate::boxed::Box::new(inner))
869 }
870 4 => {
871 let offset = u32::from_le_bytes(buf.read_const::<4>());
872 let inner = crate::vec::Vec::<super::TupleField>::decode(
873 buf.skip(offset as usize),
874 )?;
875 ExprKind::Tuple(inner)
876 }
877 5 => {
878 let offset = u32::from_le_bytes(buf.read_const::<4>());
879 let inner =
880 crate::vec::Vec::<super::Expr>::decode(buf.skip(offset as usize))?;
881 ExprKind::Array(inner)
882 }
883 6 => {
884 let offset = u32::from_le_bytes(buf.read_const::<4>());
885 let inner = super::EnumVariant::decode(buf.skip(offset as usize))?;
886 ExprKind::EnumVariant(crate::boxed::Box::new(inner))
887 }
888 7 => {
889 let offset = u32::from_le_bytes(buf.read_const::<4>());
890 let inner = super::EnumEq::decode(buf.skip(offset as usize))?;
891 ExprKind::EnumEq(crate::boxed::Box::new(inner))
892 }
893 8 => {
894 let offset = u32::from_le_bytes(buf.read_const::<4>());
895 let inner = super::EnumUnwrap::decode(buf.skip(offset as usize))?;
896 ExprKind::EnumUnwrap(crate::boxed::Box::new(inner))
897 }
898 9 => {
899 let offset = u32::from_le_bytes(buf.read_const::<4>());
900 let inner = super::TupleLookup::decode(buf.skip(offset as usize))?;
901 ExprKind::TupleLookup(crate::boxed::Box::new(inner))
902 }
903 10 => {
904 let offset = u32::from_le_bytes(buf.read_const::<4>());
905 let inner = super::Binding::decode(buf.skip(offset as usize))?;
906 ExprKind::Binding(crate::boxed::Box::new(inner))
907 }
908 11 => {
909 let offset = u32::from_le_bytes(buf.read_const::<4>());
910 let inner = crate::vec::Vec::<super::SwitchBranch>::decode(
911 buf.skip(offset as usize),
912 )?;
913 ExprKind::Switch(inner)
914 }
915 _ => return Err(crate::Error::InvalidData),
916 })
917 }
918 }
919
920 #[allow(unused_variables)]
921 #[allow(clippy::all)]
922 impl crate::Encode for Pointer {
923 type HeadPtr = PointerHeadPtr;
924 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> PointerHeadPtr {
925 match self {
926 Self::External(inner) => {
927 w.put_slice(&[0]);
928 let head_ptr = crate::ReversePointer::new(w);
929 let r = PointerHeadPtr::External(head_ptr);
930 r
931 }
932 Self::Binding(inner) => {
933 w.put_slice(&[1]);
934 let head_ptr = crate::ReversePointer::new(w);
935 let r = PointerHeadPtr::Binding(head_ptr);
936 r
937 }
938 Self::Parameter(inner) => {
939 w.put_slice(&[2]);
940 let head_ptr = crate::ReversePointer::new(w);
941 let r = PointerHeadPtr::Parameter(head_ptr);
942 r
943 }
944 }
945 }
946 fn encode_body(&self, head: PointerHeadPtr, w: &mut crate::bytes::BytesMut) {
947 match self {
948 Self::External(inner) => {
949 let PointerHeadPtr::External(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 Self::Binding(inner) => {
957 let PointerHeadPtr::Binding(offset_ptr) = head else {
958 unreachable!()
959 };
960 offset_ptr.write_cur_len(w);
961 let inner_head_ptr = inner.encode_head(w);
962 inner.encode_body(inner_head_ptr, w);
963 }
964 Self::Parameter(inner) => {
965 let PointerHeadPtr::Parameter(offset_ptr) = head else {
966 unreachable!()
967 };
968 offset_ptr.write_cur_len(w);
969 let inner_head_ptr = inner.encode_head(w);
970 inner.encode_body(inner_head_ptr, w);
971 }
972 }
973 }
974 }
975 #[allow(non_camel_case_types, dead_code)]
976 pub enum PointerHeadPtr {
977 None,
978 External(crate::ReversePointer),
979 Binding(crate::ReversePointer),
980 Parameter(crate::ReversePointer),
981 }
982 impl crate::Layout for Pointer {
983 fn head_size() -> usize {
984 40
985 }
986 }
987
988 impl crate::Decode for Pointer {
989 fn decode(buf: &[u8]) -> crate::Result<Self> {
990 let mut tag_bytes = buf.read_n(1).to_vec();
991 tag_bytes.resize(8, 0);
992 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
993 let buf = buf.skip(1);
994 Ok(match tag {
995 0 => {
996 let offset = u32::from_le_bytes(buf.read_const::<4>());
997 let inner = super::ExternalPtr::decode(buf.skip(offset as usize))?;
998 Pointer::External(inner)
999 }
1000 1 => {
1001 let offset = u32::from_le_bytes(buf.read_const::<4>());
1002 let inner = u32::decode(buf.skip(offset as usize))?;
1003 Pointer::Binding(inner)
1004 }
1005 2 => {
1006 let offset = u32::from_le_bytes(buf.read_const::<4>());
1007 let inner = super::ParameterPtr::decode(buf.skip(offset as usize))?;
1008 Pointer::Parameter(inner)
1009 }
1010 _ => return Err(crate::Error::InvalidData),
1011 })
1012 }
1013 }
1014
1015 #[allow(clippy::all, unused_variables)]
1016 impl crate::Encode for ExternalPtr {
1017 type HeadPtr = ExternalPtrHeadPtr;
1018 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1019 let id = self.id.encode_head(buf);
1020 ExternalPtrHeadPtr { id }
1021 }
1022 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1023 self.id.encode_body(head.id, buf);
1024 }
1025 }
1026 #[allow(non_camel_case_types)]
1027 pub struct ExternalPtrHeadPtr {
1028 id: <crate::string::String as crate::Encode>::HeadPtr,
1029 }
1030 impl crate::Layout for ExternalPtr {
1031 fn head_size() -> usize {
1032 64
1033 }
1034 }
1035
1036 impl crate::Decode for ExternalPtr {
1037 fn decode(buf: &[u8]) -> crate::Result<Self> {
1038 let id = crate::string::String::decode(buf.skip(0))?;
1039 Ok(ExternalPtr { id })
1040 }
1041 }
1042
1043 #[allow(clippy::all, unused_variables)]
1044 impl crate::Encode for ParameterPtr {
1045 type HeadPtr = ParameterPtrHeadPtr;
1046 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1047 let function_id = self.function_id.encode_head(buf);
1048 let param_position = self.param_position.encode_head(buf);
1049 ParameterPtrHeadPtr {
1050 function_id,
1051 param_position,
1052 }
1053 }
1054 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1055 self.function_id.encode_body(head.function_id, buf);
1056 self.param_position.encode_body(head.param_position, buf);
1057 }
1058 }
1059 #[allow(non_camel_case_types)]
1060 pub struct ParameterPtrHeadPtr {
1061 function_id: <u32 as crate::Encode>::HeadPtr,
1062 param_position: <u8 as crate::Encode>::HeadPtr,
1063 }
1064 impl crate::Layout for ParameterPtr {
1065 fn head_size() -> usize {
1066 40
1067 }
1068 }
1069
1070 impl crate::Decode for ParameterPtr {
1071 fn decode(buf: &[u8]) -> crate::Result<Self> {
1072 let function_id = u32::decode(buf.skip(0))?;
1073 let param_position = u8::decode(buf.skip(4))?;
1074 Ok(ParameterPtr {
1075 function_id,
1076 param_position,
1077 })
1078 }
1079 }
1080
1081 #[allow(unused_variables)]
1082 #[allow(clippy::all)]
1083 impl crate::Encode for Literal {
1084 type HeadPtr = LiteralHeadPtr;
1085 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> LiteralHeadPtr {
1086 match self {
1087 Self::bool(inner) => {
1088 w.put_slice(&[0]);
1089 let head_ptr = crate::ReversePointer::new(w);
1090 let r = LiteralHeadPtr::bool(head_ptr);
1091 r
1092 }
1093 Self::int8(inner) => {
1094 w.put_slice(&[1]);
1095 let head_ptr = crate::ReversePointer::new(w);
1096 let r = LiteralHeadPtr::int8(head_ptr);
1097 r
1098 }
1099 Self::int16(inner) => {
1100 w.put_slice(&[2]);
1101 let head_ptr = crate::ReversePointer::new(w);
1102 let r = LiteralHeadPtr::int16(head_ptr);
1103 r
1104 }
1105 Self::int32(inner) => {
1106 w.put_slice(&[3]);
1107 let head_ptr = crate::ReversePointer::new(w);
1108 let r = LiteralHeadPtr::int32(head_ptr);
1109 r
1110 }
1111 Self::int64(inner) => {
1112 w.put_slice(&[4]);
1113 let head_ptr = crate::ReversePointer::new(w);
1114 let r = LiteralHeadPtr::int64(head_ptr);
1115 r
1116 }
1117 Self::uint8(inner) => {
1118 w.put_slice(&[5]);
1119 let head_ptr = crate::ReversePointer::new(w);
1120 let r = LiteralHeadPtr::uint8(head_ptr);
1121 r
1122 }
1123 Self::uint16(inner) => {
1124 w.put_slice(&[6]);
1125 let head_ptr = crate::ReversePointer::new(w);
1126 let r = LiteralHeadPtr::uint16(head_ptr);
1127 r
1128 }
1129 Self::uint32(inner) => {
1130 w.put_slice(&[7]);
1131 let head_ptr = crate::ReversePointer::new(w);
1132 let r = LiteralHeadPtr::uint32(head_ptr);
1133 r
1134 }
1135 Self::uint64(inner) => {
1136 w.put_slice(&[8]);
1137 let head_ptr = crate::ReversePointer::new(w);
1138 let r = LiteralHeadPtr::uint64(head_ptr);
1139 r
1140 }
1141 Self::float32(inner) => {
1142 w.put_slice(&[9]);
1143 let head_ptr = crate::ReversePointer::new(w);
1144 let r = LiteralHeadPtr::float32(head_ptr);
1145 r
1146 }
1147 Self::float64(inner) => {
1148 w.put_slice(&[10]);
1149 let head_ptr = crate::ReversePointer::new(w);
1150 let r = LiteralHeadPtr::float64(head_ptr);
1151 r
1152 }
1153 Self::text(inner) => {
1154 w.put_slice(&[11]);
1155 let head_ptr = crate::ReversePointer::new(w);
1156 let r = LiteralHeadPtr::text(head_ptr);
1157 r
1158 }
1159 }
1160 }
1161 fn encode_body(&self, head: LiteralHeadPtr, w: &mut crate::bytes::BytesMut) {
1162 match self {
1163 Self::bool(inner) => {
1164 let LiteralHeadPtr::bool(offset_ptr) = head else {
1165 unreachable!()
1166 };
1167 offset_ptr.write_cur_len(w);
1168 let inner_head_ptr = inner.encode_head(w);
1169 inner.encode_body(inner_head_ptr, w);
1170 }
1171 Self::int8(inner) => {
1172 let LiteralHeadPtr::int8(offset_ptr) = head else {
1173 unreachable!()
1174 };
1175 offset_ptr.write_cur_len(w);
1176 let inner_head_ptr = inner.encode_head(w);
1177 inner.encode_body(inner_head_ptr, w);
1178 }
1179 Self::int16(inner) => {
1180 let LiteralHeadPtr::int16(offset_ptr) = head else {
1181 unreachable!()
1182 };
1183 offset_ptr.write_cur_len(w);
1184 let inner_head_ptr = inner.encode_head(w);
1185 inner.encode_body(inner_head_ptr, w);
1186 }
1187 Self::int32(inner) => {
1188 let LiteralHeadPtr::int32(offset_ptr) = head else {
1189 unreachable!()
1190 };
1191 offset_ptr.write_cur_len(w);
1192 let inner_head_ptr = inner.encode_head(w);
1193 inner.encode_body(inner_head_ptr, w);
1194 }
1195 Self::int64(inner) => {
1196 let LiteralHeadPtr::int64(offset_ptr) = head else {
1197 unreachable!()
1198 };
1199 offset_ptr.write_cur_len(w);
1200 let inner_head_ptr = inner.encode_head(w);
1201 inner.encode_body(inner_head_ptr, w);
1202 }
1203 Self::uint8(inner) => {
1204 let LiteralHeadPtr::uint8(offset_ptr) = head else {
1205 unreachable!()
1206 };
1207 offset_ptr.write_cur_len(w);
1208 let inner_head_ptr = inner.encode_head(w);
1209 inner.encode_body(inner_head_ptr, w);
1210 }
1211 Self::uint16(inner) => {
1212 let LiteralHeadPtr::uint16(offset_ptr) = head else {
1213 unreachable!()
1214 };
1215 offset_ptr.write_cur_len(w);
1216 let inner_head_ptr = inner.encode_head(w);
1217 inner.encode_body(inner_head_ptr, w);
1218 }
1219 Self::uint32(inner) => {
1220 let LiteralHeadPtr::uint32(offset_ptr) = head else {
1221 unreachable!()
1222 };
1223 offset_ptr.write_cur_len(w);
1224 let inner_head_ptr = inner.encode_head(w);
1225 inner.encode_body(inner_head_ptr, w);
1226 }
1227 Self::uint64(inner) => {
1228 let LiteralHeadPtr::uint64(offset_ptr) = head else {
1229 unreachable!()
1230 };
1231 offset_ptr.write_cur_len(w);
1232 let inner_head_ptr = inner.encode_head(w);
1233 inner.encode_body(inner_head_ptr, w);
1234 }
1235 Self::float32(inner) => {
1236 let LiteralHeadPtr::float32(offset_ptr) = head else {
1237 unreachable!()
1238 };
1239 offset_ptr.write_cur_len(w);
1240 let inner_head_ptr = inner.encode_head(w);
1241 inner.encode_body(inner_head_ptr, w);
1242 }
1243 Self::float64(inner) => {
1244 let LiteralHeadPtr::float64(offset_ptr) = head else {
1245 unreachable!()
1246 };
1247 offset_ptr.write_cur_len(w);
1248 let inner_head_ptr = inner.encode_head(w);
1249 inner.encode_body(inner_head_ptr, w);
1250 }
1251 Self::text(inner) => {
1252 let LiteralHeadPtr::text(offset_ptr) = head else {
1253 unreachable!()
1254 };
1255 offset_ptr.write_cur_len(w);
1256 let inner_head_ptr = inner.encode_head(w);
1257 inner.encode_body(inner_head_ptr, w);
1258 }
1259 }
1260 }
1261 }
1262 #[allow(non_camel_case_types, dead_code)]
1263 pub enum LiteralHeadPtr {
1264 None,
1265 bool(crate::ReversePointer),
1266 int8(crate::ReversePointer),
1267 int16(crate::ReversePointer),
1268 int32(crate::ReversePointer),
1269 int64(crate::ReversePointer),
1270 uint8(crate::ReversePointer),
1271 uint16(crate::ReversePointer),
1272 uint32(crate::ReversePointer),
1273 uint64(crate::ReversePointer),
1274 float32(crate::ReversePointer),
1275 float64(crate::ReversePointer),
1276 text(crate::ReversePointer),
1277 }
1278 impl crate::Layout for Literal {
1279 fn head_size() -> usize {
1280 40
1281 }
1282 }
1283
1284 impl crate::Decode for Literal {
1285 fn decode(buf: &[u8]) -> crate::Result<Self> {
1286 let mut tag_bytes = buf.read_n(1).to_vec();
1287 tag_bytes.resize(8, 0);
1288 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1289 let buf = buf.skip(1);
1290 Ok(match tag {
1291 0 => {
1292 let offset = u32::from_le_bytes(buf.read_const::<4>());
1293 let inner = bool::decode(buf.skip(offset as usize))?;
1294 Literal::bool(inner)
1295 }
1296 1 => {
1297 let offset = u32::from_le_bytes(buf.read_const::<4>());
1298 let inner = i8::decode(buf.skip(offset as usize))?;
1299 Literal::int8(inner)
1300 }
1301 2 => {
1302 let offset = u32::from_le_bytes(buf.read_const::<4>());
1303 let inner = i16::decode(buf.skip(offset as usize))?;
1304 Literal::int16(inner)
1305 }
1306 3 => {
1307 let offset = u32::from_le_bytes(buf.read_const::<4>());
1308 let inner = i32::decode(buf.skip(offset as usize))?;
1309 Literal::int32(inner)
1310 }
1311 4 => {
1312 let offset = u32::from_le_bytes(buf.read_const::<4>());
1313 let inner = i64::decode(buf.skip(offset as usize))?;
1314 Literal::int64(inner)
1315 }
1316 5 => {
1317 let offset = u32::from_le_bytes(buf.read_const::<4>());
1318 let inner = u8::decode(buf.skip(offset as usize))?;
1319 Literal::uint8(inner)
1320 }
1321 6 => {
1322 let offset = u32::from_le_bytes(buf.read_const::<4>());
1323 let inner = u16::decode(buf.skip(offset as usize))?;
1324 Literal::uint16(inner)
1325 }
1326 7 => {
1327 let offset = u32::from_le_bytes(buf.read_const::<4>());
1328 let inner = u32::decode(buf.skip(offset as usize))?;
1329 Literal::uint32(inner)
1330 }
1331 8 => {
1332 let offset = u32::from_le_bytes(buf.read_const::<4>());
1333 let inner = u64::decode(buf.skip(offset as usize))?;
1334 Literal::uint64(inner)
1335 }
1336 9 => {
1337 let offset = u32::from_le_bytes(buf.read_const::<4>());
1338 let inner = f32::decode(buf.skip(offset as usize))?;
1339 Literal::float32(inner)
1340 }
1341 10 => {
1342 let offset = u32::from_le_bytes(buf.read_const::<4>());
1343 let inner = f64::decode(buf.skip(offset as usize))?;
1344 Literal::float64(inner)
1345 }
1346 11 => {
1347 let offset = u32::from_le_bytes(buf.read_const::<4>());
1348 let inner = crate::string::String::decode(buf.skip(offset as usize))?;
1349 Literal::text(inner)
1350 }
1351 _ => return Err(crate::Error::InvalidData),
1352 })
1353 }
1354 }
1355
1356 #[allow(clippy::all, unused_variables)]
1357 impl crate::Encode for Call {
1358 type HeadPtr = CallHeadPtr;
1359 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1360 let function = self.function.encode_head(buf);
1361 let args = self.args.encode_head(buf);
1362 CallHeadPtr { function, args }
1363 }
1364 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1365 self.function.encode_body(head.function, buf);
1366 self.args.encode_body(head.args, buf);
1367 }
1368 }
1369 #[allow(non_camel_case_types)]
1370 pub struct CallHeadPtr {
1371 function: <super::Expr as crate::Encode>::HeadPtr,
1372 args: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
1373 }
1374 impl crate::Layout for Call {
1375 fn head_size() -> usize {
1376 288
1377 }
1378 }
1379
1380 impl crate::Decode for Call {
1381 fn decode(buf: &[u8]) -> crate::Result<Self> {
1382 let function = super::Expr::decode(buf.skip(0))?;
1383 let args = crate::vec::Vec::<super::Expr>::decode(buf.skip(28))?;
1384 Ok(Call { function, args })
1385 }
1386 }
1387
1388 #[allow(clippy::all, unused_variables)]
1389 impl crate::Encode for Function {
1390 type HeadPtr = FunctionHeadPtr;
1391 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1392 let id = self.id.encode_head(buf);
1393 let body = self.body.encode_head(buf);
1394 FunctionHeadPtr { id, body }
1395 }
1396 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1397 self.id.encode_body(head.id, buf);
1398 self.body.encode_body(head.body, buf);
1399 }
1400 }
1401 #[allow(non_camel_case_types)]
1402 pub struct FunctionHeadPtr {
1403 id: <u32 as crate::Encode>::HeadPtr,
1404 body: <super::Expr as crate::Encode>::HeadPtr,
1405 }
1406 impl crate::Layout for Function {
1407 fn head_size() -> usize {
1408 256
1409 }
1410 }
1411
1412 impl crate::Decode for Function {
1413 fn decode(buf: &[u8]) -> crate::Result<Self> {
1414 let id = u32::decode(buf.skip(0))?;
1415 let body = super::Expr::decode(buf.skip(4))?;
1416 Ok(Function { id, body })
1417 }
1418 }
1419
1420 #[allow(clippy::all, unused_variables)]
1421 impl crate::Encode for TupleField {
1422 type HeadPtr = TupleFieldHeadPtr;
1423 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1424 let expr = self.expr.encode_head(buf);
1425 let unpack = self.unpack.encode_head(buf);
1426 TupleFieldHeadPtr { expr, unpack }
1427 }
1428 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1429 self.expr.encode_body(head.expr, buf);
1430 self.unpack.encode_body(head.unpack, buf);
1431 }
1432 }
1433 #[allow(non_camel_case_types)]
1434 pub struct TupleFieldHeadPtr {
1435 expr: <super::Expr as crate::Encode>::HeadPtr,
1436 unpack: <bool as crate::Encode>::HeadPtr,
1437 }
1438 impl crate::Layout for TupleField {
1439 fn head_size() -> usize {
1440 232
1441 }
1442 }
1443
1444 impl crate::Decode for TupleField {
1445 fn decode(buf: &[u8]) -> crate::Result<Self> {
1446 let expr = super::Expr::decode(buf.skip(0))?;
1447 let unpack = bool::decode(buf.skip(28))?;
1448 Ok(TupleField { expr, unpack })
1449 }
1450 }
1451
1452 #[allow(clippy::all, unused_variables)]
1453 impl crate::Encode for EnumVariant {
1454 type HeadPtr = EnumVariantHeadPtr;
1455 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1456 let tag = self.tag.encode_head(buf);
1457 let inner = self.inner.encode_head(buf);
1458 EnumVariantHeadPtr { tag, inner }
1459 }
1460 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1461 self.tag.encode_body(head.tag, buf);
1462 self.inner.encode_body(head.inner, buf);
1463 }
1464 }
1465 #[allow(non_camel_case_types)]
1466 pub struct EnumVariantHeadPtr {
1467 tag: <u64 as crate::Encode>::HeadPtr,
1468 inner: <super::Expr as crate::Encode>::HeadPtr,
1469 }
1470 impl crate::Layout for EnumVariant {
1471 fn head_size() -> usize {
1472 288
1473 }
1474 }
1475
1476 impl crate::Decode for EnumVariant {
1477 fn decode(buf: &[u8]) -> crate::Result<Self> {
1478 let tag = u64::decode(buf.skip(0))?;
1479 let inner = super::Expr::decode(buf.skip(8))?;
1480 Ok(EnumVariant { tag, inner })
1481 }
1482 }
1483
1484 #[allow(clippy::all, unused_variables)]
1485 impl crate::Encode for EnumEq {
1486 type HeadPtr = EnumEqHeadPtr;
1487 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1488 let subject = self.subject.encode_head(buf);
1489 let tag = self.tag.encode_head(buf);
1490 EnumEqHeadPtr { subject, tag }
1491 }
1492 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1493 self.subject.encode_body(head.subject, buf);
1494 self.tag.encode_body(head.tag, buf);
1495 }
1496 }
1497 #[allow(non_camel_case_types)]
1498 pub struct EnumEqHeadPtr {
1499 subject: <super::Expr as crate::Encode>::HeadPtr,
1500 tag: <u64 as crate::Encode>::HeadPtr,
1501 }
1502 impl crate::Layout for EnumEq {
1503 fn head_size() -> usize {
1504 288
1505 }
1506 }
1507
1508 impl crate::Decode for EnumEq {
1509 fn decode(buf: &[u8]) -> crate::Result<Self> {
1510 let subject = super::Expr::decode(buf.skip(0))?;
1511 let tag = u64::decode(buf.skip(28))?;
1512 Ok(EnumEq { subject, tag })
1513 }
1514 }
1515
1516 #[allow(clippy::all, unused_variables)]
1517 impl crate::Encode for EnumUnwrap {
1518 type HeadPtr = EnumUnwrapHeadPtr;
1519 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1520 let subject = self.subject.encode_head(buf);
1521 let tag = self.tag.encode_head(buf);
1522 EnumUnwrapHeadPtr { subject, tag }
1523 }
1524 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1525 self.subject.encode_body(head.subject, buf);
1526 self.tag.encode_body(head.tag, buf);
1527 }
1528 }
1529 #[allow(non_camel_case_types)]
1530 pub struct EnumUnwrapHeadPtr {
1531 subject: <super::Expr as crate::Encode>::HeadPtr,
1532 tag: <u64 as crate::Encode>::HeadPtr,
1533 }
1534 impl crate::Layout for EnumUnwrap {
1535 fn head_size() -> usize {
1536 288
1537 }
1538 }
1539
1540 impl crate::Decode for EnumUnwrap {
1541 fn decode(buf: &[u8]) -> crate::Result<Self> {
1542 let subject = super::Expr::decode(buf.skip(0))?;
1543 let tag = u64::decode(buf.skip(28))?;
1544 Ok(EnumUnwrap { subject, tag })
1545 }
1546 }
1547
1548 #[allow(clippy::all, unused_variables)]
1549 impl crate::Encode for TupleLookup {
1550 type HeadPtr = TupleLookupHeadPtr;
1551 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1552 let base = self.base.encode_head(buf);
1553 let position = self.position.encode_head(buf);
1554 TupleLookupHeadPtr { base, position }
1555 }
1556 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1557 self.base.encode_body(head.base, buf);
1558 self.position.encode_body(head.position, buf);
1559 }
1560 }
1561 #[allow(non_camel_case_types)]
1562 pub struct TupleLookupHeadPtr {
1563 base: <super::Expr as crate::Encode>::HeadPtr,
1564 position: <u16 as crate::Encode>::HeadPtr,
1565 }
1566 impl crate::Layout for TupleLookup {
1567 fn head_size() -> usize {
1568 240
1569 }
1570 }
1571
1572 impl crate::Decode for TupleLookup {
1573 fn decode(buf: &[u8]) -> crate::Result<Self> {
1574 let base = super::Expr::decode(buf.skip(0))?;
1575 let position = u16::decode(buf.skip(28))?;
1576 Ok(TupleLookup { base, position })
1577 }
1578 }
1579
1580 #[allow(clippy::all, unused_variables)]
1581 impl crate::Encode for Binding {
1582 type HeadPtr = BindingHeadPtr;
1583 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1584 let id = self.id.encode_head(buf);
1585 let expr = self.expr.encode_head(buf);
1586 let main = self.main.encode_head(buf);
1587 BindingHeadPtr { id, expr, main }
1588 }
1589 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1590 self.id.encode_body(head.id, buf);
1591 self.expr.encode_body(head.expr, buf);
1592 self.main.encode_body(head.main, buf);
1593 }
1594 }
1595 #[allow(non_camel_case_types)]
1596 pub struct BindingHeadPtr {
1597 id: <u32 as crate::Encode>::HeadPtr,
1598 expr: <super::Expr as crate::Encode>::HeadPtr,
1599 main: <super::Expr as crate::Encode>::HeadPtr,
1600 }
1601 impl crate::Layout for Binding {
1602 fn head_size() -> usize {
1603 480
1604 }
1605 }
1606
1607 impl crate::Decode for Binding {
1608 fn decode(buf: &[u8]) -> crate::Result<Self> {
1609 let id = u32::decode(buf.skip(0))?;
1610 let expr = super::Expr::decode(buf.skip(4))?;
1611 let main = super::Expr::decode(buf.skip(32))?;
1612 Ok(Binding { id, expr, main })
1613 }
1614 }
1615
1616 #[allow(clippy::all, unused_variables)]
1617 impl crate::Encode for SwitchBranch {
1618 type HeadPtr = SwitchBranchHeadPtr;
1619 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1620 let condition = self.condition.encode_head(buf);
1621 let value = self.value.encode_head(buf);
1622 SwitchBranchHeadPtr { condition, value }
1623 }
1624 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1625 self.condition.encode_body(head.condition, buf);
1626 self.value.encode_body(head.value, buf);
1627 }
1628 }
1629 #[allow(non_camel_case_types)]
1630 pub struct SwitchBranchHeadPtr {
1631 condition: <super::Expr as crate::Encode>::HeadPtr,
1632 value: <super::Expr as crate::Encode>::HeadPtr,
1633 }
1634 impl crate::Layout for SwitchBranch {
1635 fn head_size() -> usize {
1636 448
1637 }
1638 }
1639
1640 impl crate::Decode for SwitchBranch {
1641 fn decode(buf: &[u8]) -> crate::Result<Self> {
1642 let condition = super::Expr::decode(buf.skip(0))?;
1643 let value = super::Expr::decode(buf.skip(28))?;
1644 Ok(SwitchBranch { condition, value })
1645 }
1646 }
1647
1648 #[allow(clippy::all, unused_variables)]
1649 impl crate::Encode for TyDef {
1650 type HeadPtr = TyDefHeadPtr;
1651 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1652 let name = self.name.encode_head(buf);
1653 let ty = self.ty.encode_head(buf);
1654 TyDefHeadPtr { name, ty }
1655 }
1656 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1657 self.name.encode_body(head.name, buf);
1658 self.ty.encode_body(head.ty, buf);
1659 }
1660 }
1661 #[allow(non_camel_case_types)]
1662 pub struct TyDefHeadPtr {
1663 name: <super::Path as crate::Encode>::HeadPtr,
1664 ty: <super::Ty as crate::Encode>::HeadPtr,
1665 }
1666 impl crate::Layout for TyDef {
1667 fn head_size() -> usize {
1668 248
1669 }
1670 }
1671
1672 impl crate::Decode for TyDef {
1673 fn decode(buf: &[u8]) -> crate::Result<Self> {
1674 let name = super::Path::decode(buf.skip(0))?;
1675 let ty = super::Ty::decode(buf.skip(8))?;
1676 Ok(TyDef { name, ty })
1677 }
1678 }
1679
1680 #[allow(clippy::all, unused_variables)]
1681 impl crate::Encode for Ty {
1682 type HeadPtr = TyHeadPtr;
1683 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1684 let kind = self.kind.encode_head(buf);
1685 let layout = self.layout.encode_head(buf);
1686 let name = self.name.encode_head(buf);
1687 let variants_recursive = self.variants_recursive.encode_head(buf);
1688 TyHeadPtr {
1689 kind,
1690 layout,
1691 name,
1692 variants_recursive,
1693 }
1694 }
1695 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1696 self.kind.encode_body(head.kind, buf);
1697 self.layout.encode_body(head.layout, buf);
1698 self.name.encode_body(head.name, buf);
1699 self.variants_recursive
1700 .encode_body(head.variants_recursive, buf);
1701 }
1702 }
1703 #[allow(non_camel_case_types)]
1704 pub struct TyHeadPtr {
1705 kind: <super::TyKind as crate::Encode>::HeadPtr,
1706 layout: <core::option::Option<super::TyLayout> as crate::Encode>::HeadPtr,
1707 name: <core::option::Option<crate::string::String> as crate::Encode>::HeadPtr,
1708 variants_recursive: <crate::vec::Vec<u16> as crate::Encode>::HeadPtr,
1709 }
1710 impl crate::Layout for Ty {
1711 fn head_size() -> usize {
1712 184
1713 }
1714 }
1715
1716 impl crate::Decode for Ty {
1717 fn decode(buf: &[u8]) -> crate::Result<Self> {
1718 let kind = super::TyKind::decode(buf.skip(0))?;
1719 let layout = core::option::Option::<super::TyLayout>::decode(buf.skip(5))?;
1720 let name = core::option::Option::<crate::string::String>::decode(buf.skip(10))?;
1721 let variants_recursive = crate::vec::Vec::<u16>::decode(buf.skip(15))?;
1722 Ok(Ty {
1723 kind,
1724 layout,
1725 name,
1726 variants_recursive,
1727 })
1728 }
1729 }
1730
1731 #[allow(unused_variables)]
1732 #[allow(clippy::all)]
1733 impl crate::Encode for TyKind {
1734 type HeadPtr = TyKindHeadPtr;
1735 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> TyKindHeadPtr {
1736 match self {
1737 Self::Primitive(inner) => {
1738 w.put_slice(&[0]);
1739 let head_ptr = crate::ReversePointer::new(w);
1740 let r = TyKindHeadPtr::Primitive(head_ptr);
1741 r
1742 }
1743 Self::Tuple(inner) => {
1744 w.put_slice(&[1]);
1745 let head_ptr = crate::ReversePointer::new(w);
1746 let r = TyKindHeadPtr::Tuple(head_ptr);
1747 r
1748 }
1749 Self::Array(inner) => {
1750 w.put_slice(&[2]);
1751 let head_ptr = crate::ReversePointer::new(w);
1752 let r = TyKindHeadPtr::Array(head_ptr);
1753 r
1754 }
1755 Self::Enum(inner) => {
1756 w.put_slice(&[3]);
1757 let head_ptr = crate::ReversePointer::new(w);
1758 let r = TyKindHeadPtr::Enum(head_ptr);
1759 r
1760 }
1761 Self::Function(inner) => {
1762 w.put_slice(&[4]);
1763 let head_ptr = crate::ReversePointer::new(w);
1764 let r = TyKindHeadPtr::Function(head_ptr);
1765 r
1766 }
1767 Self::Ident(inner) => {
1768 w.put_slice(&[5]);
1769 let head_ptr = crate::ReversePointer::new(w);
1770 let r = TyKindHeadPtr::Ident(head_ptr);
1771 r
1772 }
1773 }
1774 }
1775 fn encode_body(&self, head: TyKindHeadPtr, w: &mut crate::bytes::BytesMut) {
1776 match self {
1777 Self::Primitive(inner) => {
1778 let TyKindHeadPtr::Primitive(offset_ptr) = head else {
1779 unreachable!()
1780 };
1781 offset_ptr.write_cur_len(w);
1782 let inner_head_ptr = inner.encode_head(w);
1783 inner.encode_body(inner_head_ptr, w);
1784 }
1785 Self::Tuple(inner) => {
1786 let TyKindHeadPtr::Tuple(offset_ptr) = head else {
1787 unreachable!()
1788 };
1789 offset_ptr.write_cur_len(w);
1790 let inner_head_ptr = inner.encode_head(w);
1791 inner.encode_body(inner_head_ptr, w);
1792 }
1793 Self::Array(inner) => {
1794 let TyKindHeadPtr::Array(offset_ptr) = head else {
1795 unreachable!()
1796 };
1797 offset_ptr.write_cur_len(w);
1798 let inner_head_ptr = inner.encode_head(w);
1799 inner.encode_body(inner_head_ptr, w);
1800 }
1801 Self::Enum(inner) => {
1802 let TyKindHeadPtr::Enum(offset_ptr) = head else {
1803 unreachable!()
1804 };
1805 offset_ptr.write_cur_len(w);
1806 let inner_head_ptr = inner.encode_head(w);
1807 inner.encode_body(inner_head_ptr, w);
1808 }
1809 Self::Function(inner) => {
1810 let TyKindHeadPtr::Function(offset_ptr) = head else {
1811 unreachable!()
1812 };
1813 offset_ptr.write_cur_len(w);
1814 let inner_head_ptr = inner.encode_head(w);
1815 inner.encode_body(inner_head_ptr, w);
1816 }
1817 Self::Ident(inner) => {
1818 let TyKindHeadPtr::Ident(offset_ptr) = head else {
1819 unreachable!()
1820 };
1821 offset_ptr.write_cur_len(w);
1822 let inner_head_ptr = inner.encode_head(w);
1823 inner.encode_body(inner_head_ptr, w);
1824 }
1825 }
1826 }
1827 }
1828 #[allow(non_camel_case_types, dead_code)]
1829 pub enum TyKindHeadPtr {
1830 None,
1831 Primitive(crate::ReversePointer),
1832 Tuple(crate::ReversePointer),
1833 Array(crate::ReversePointer),
1834 Enum(crate::ReversePointer),
1835 Function(crate::ReversePointer),
1836 Ident(crate::ReversePointer),
1837 }
1838 impl crate::Layout for TyKind {
1839 fn head_size() -> usize {
1840 40
1841 }
1842 }
1843
1844 impl crate::Decode for TyKind {
1845 fn decode(buf: &[u8]) -> crate::Result<Self> {
1846 let mut tag_bytes = buf.read_n(1).to_vec();
1847 tag_bytes.resize(8, 0);
1848 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1849 let buf = buf.skip(1);
1850 Ok(match tag {
1851 0 => {
1852 let offset = u32::from_le_bytes(buf.read_const::<4>());
1853 let inner = super::TyPrimitive::decode(buf.skip(offset as usize))?;
1854 TyKind::Primitive(inner)
1855 }
1856 1 => {
1857 let offset = u32::from_le_bytes(buf.read_const::<4>());
1858 let inner = crate::vec::Vec::<super::TyTupleField>::decode(
1859 buf.skip(offset as usize),
1860 )?;
1861 TyKind::Tuple(inner)
1862 }
1863 2 => {
1864 let offset = u32::from_le_bytes(buf.read_const::<4>());
1865 let inner = super::Ty::decode(buf.skip(offset as usize))?;
1866 TyKind::Array(crate::boxed::Box::new(inner))
1867 }
1868 3 => {
1869 let offset = u32::from_le_bytes(buf.read_const::<4>());
1870 let inner = crate::vec::Vec::<super::TyEnumVariant>::decode(
1871 buf.skip(offset as usize),
1872 )?;
1873 TyKind::Enum(inner)
1874 }
1875 4 => {
1876 let offset = u32::from_le_bytes(buf.read_const::<4>());
1877 let inner = super::TyFunction::decode(buf.skip(offset as usize))?;
1878 TyKind::Function(crate::boxed::Box::new(inner))
1879 }
1880 5 => {
1881 let offset = u32::from_le_bytes(buf.read_const::<4>());
1882 let inner = super::Path::decode(buf.skip(offset as usize))?;
1883 TyKind::Ident(inner)
1884 }
1885 _ => return Err(crate::Error::InvalidData),
1886 })
1887 }
1888 }
1889
1890 #[allow(unused_variables)]
1891 #[allow(clippy::all)]
1892 impl crate::Encode for TyPrimitive {
1893 type HeadPtr = ();
1894 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> () {
1895 match self {
1896 Self::bool => {
1897 w.put_slice(&[0]);
1898 }
1899 Self::int8 => {
1900 w.put_slice(&[1]);
1901 }
1902 Self::int16 => {
1903 w.put_slice(&[2]);
1904 }
1905 Self::int32 => {
1906 w.put_slice(&[3]);
1907 }
1908 Self::int64 => {
1909 w.put_slice(&[4]);
1910 }
1911 Self::uint8 => {
1912 w.put_slice(&[5]);
1913 }
1914 Self::uint16 => {
1915 w.put_slice(&[6]);
1916 }
1917 Self::uint32 => {
1918 w.put_slice(&[7]);
1919 }
1920 Self::uint64 => {
1921 w.put_slice(&[8]);
1922 }
1923 Self::float32 => {
1924 w.put_slice(&[9]);
1925 }
1926 Self::float64 => {
1927 w.put_slice(&[10]);
1928 }
1929 Self::text => {
1930 w.put_slice(&[11]);
1931 }
1932 }
1933 }
1934 fn encode_body(&self, head: (), w: &mut crate::bytes::BytesMut) {}
1935 }
1936 impl crate::Layout for TyPrimitive {
1937 fn head_size() -> usize {
1938 8
1939 }
1940 }
1941
1942 impl crate::Decode for TyPrimitive {
1943 fn decode(buf: &[u8]) -> crate::Result<Self> {
1944 let mut tag_bytes = buf.read_n(1).to_vec();
1945 tag_bytes.resize(8, 0);
1946 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
1947 Ok(match tag {
1948 0 => TyPrimitive::bool,
1949 1 => TyPrimitive::int8,
1950 2 => TyPrimitive::int16,
1951 3 => TyPrimitive::int32,
1952 4 => TyPrimitive::int64,
1953 5 => TyPrimitive::uint8,
1954 6 => TyPrimitive::uint16,
1955 7 => TyPrimitive::uint32,
1956 8 => TyPrimitive::uint64,
1957 9 => TyPrimitive::float32,
1958 10 => TyPrimitive::float64,
1959 11 => TyPrimitive::text,
1960 _ => return Err(crate::Error::InvalidData),
1961 })
1962 }
1963 }
1964
1965 #[allow(clippy::all, unused_variables)]
1966 impl crate::Encode for TyTupleField {
1967 type HeadPtr = TyTupleFieldHeadPtr;
1968 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
1969 let name = self.name.encode_head(buf);
1970 let ty = self.ty.encode_head(buf);
1971 TyTupleFieldHeadPtr { name, ty }
1972 }
1973 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
1974 self.name.encode_body(head.name, buf);
1975 self.ty.encode_body(head.ty, buf);
1976 }
1977 }
1978 #[allow(non_camel_case_types)]
1979 pub struct TyTupleFieldHeadPtr {
1980 name: <core::option::Option<crate::string::String> as crate::Encode>::HeadPtr,
1981 ty: <super::Ty as crate::Encode>::HeadPtr,
1982 }
1983 impl crate::Layout for TyTupleField {
1984 fn head_size() -> usize {
1985 224
1986 }
1987 }
1988
1989 impl crate::Decode for TyTupleField {
1990 fn decode(buf: &[u8]) -> crate::Result<Self> {
1991 let name = core::option::Option::<crate::string::String>::decode(buf.skip(0))?;
1992 let ty = super::Ty::decode(buf.skip(5))?;
1993 Ok(TyTupleField { name, ty })
1994 }
1995 }
1996
1997 #[allow(clippy::all, unused_variables)]
1998 impl crate::Encode for TyEnumVariant {
1999 type HeadPtr = TyEnumVariantHeadPtr;
2000 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2001 let name = self.name.encode_head(buf);
2002 let ty = self.ty.encode_head(buf);
2003 TyEnumVariantHeadPtr { name, ty }
2004 }
2005 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2006 self.name.encode_body(head.name, buf);
2007 self.ty.encode_body(head.ty, buf);
2008 }
2009 }
2010 #[allow(non_camel_case_types)]
2011 pub struct TyEnumVariantHeadPtr {
2012 name: <crate::string::String as crate::Encode>::HeadPtr,
2013 ty: <super::Ty as crate::Encode>::HeadPtr,
2014 }
2015 impl crate::Layout for TyEnumVariant {
2016 fn head_size() -> usize {
2017 248
2018 }
2019 }
2020
2021 impl crate::Decode for TyEnumVariant {
2022 fn decode(buf: &[u8]) -> crate::Result<Self> {
2023 let name = crate::string::String::decode(buf.skip(0))?;
2024 let ty = super::Ty::decode(buf.skip(8))?;
2025 Ok(TyEnumVariant { name, ty })
2026 }
2027 }
2028
2029 #[allow(clippy::all, unused_variables)]
2030 impl crate::Encode for TyLayout {
2031 type HeadPtr = TyLayoutHeadPtr;
2032 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2033 let head_size = self.head_size.encode_head(buf);
2034 let body_ptrs = self.body_ptrs.encode_head(buf);
2035 TyLayoutHeadPtr {
2036 head_size,
2037 body_ptrs,
2038 }
2039 }
2040 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2041 self.head_size.encode_body(head.head_size, buf);
2042 self.body_ptrs.encode_body(head.body_ptrs, buf);
2043 }
2044 }
2045 #[allow(non_camel_case_types)]
2046 pub struct TyLayoutHeadPtr {
2047 head_size: <u32 as crate::Encode>::HeadPtr,
2048 body_ptrs: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
2049 }
2050 impl crate::Layout for TyLayout {
2051 fn head_size() -> usize {
2052 96
2053 }
2054 }
2055
2056 impl crate::Decode for TyLayout {
2057 fn decode(buf: &[u8]) -> crate::Result<Self> {
2058 let head_size = u32::decode(buf.skip(0))?;
2059 let body_ptrs = crate::vec::Vec::<u32>::decode(buf.skip(4))?;
2060 Ok(TyLayout {
2061 head_size,
2062 body_ptrs,
2063 })
2064 }
2065 }
2066
2067 #[allow(clippy::all, unused_variables)]
2068 impl crate::Encode for TyFunction {
2069 type HeadPtr = TyFunctionHeadPtr;
2070 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2071 let params = self.params.encode_head(buf);
2072 let body = self.body.encode_head(buf);
2073 TyFunctionHeadPtr { params, body }
2074 }
2075 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2076 self.params.encode_body(head.params, buf);
2077 self.body.encode_body(head.body, buf);
2078 }
2079 }
2080 #[allow(non_camel_case_types)]
2081 pub struct TyFunctionHeadPtr {
2082 params: <crate::vec::Vec<super::Ty> as crate::Encode>::HeadPtr,
2083 body: <super::Ty as crate::Encode>::HeadPtr,
2084 }
2085 impl crate::Layout for TyFunction {
2086 fn head_size() -> usize {
2087 248
2088 }
2089 }
2090
2091 impl crate::Decode for TyFunction {
2092 fn decode(buf: &[u8]) -> crate::Result<Self> {
2093 let params = crate::vec::Vec::<super::Ty>::decode(buf.skip(0))?;
2094 let body = super::Ty::decode(buf.skip(8))?;
2095 Ok(TyFunction { params, body })
2096 }
2097 }
2098
2099 impl crate::Encode for Path {
2100 type HeadPtr = crate::ReversePointer;
2101 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2102 self.0.encode_head(buf)
2103 }
2104 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2105 self.0.encode_body(head, buf)
2106 }
2107 }
2108 impl crate::Layout for Path {
2109 fn head_size() -> usize {
2110 64
2111 }
2112 }
2113
2114 impl crate::Decode for Path {
2115 fn decode(buf: &[u8]) -> crate::Result<Self> {
2116 Ok(Self(crate::vec::Vec::<crate::string::String>::decode(buf)?))
2117 }
2118 }
2119
2120 #[allow(clippy::all, unused_variables)]
2121 impl crate::Encode for Module {
2122 type HeadPtr = ModuleHeadPtr;
2123 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2124 let decls = self.decls.encode_head(buf);
2125 ModuleHeadPtr { decls }
2126 }
2127 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2128 self.decls.encode_body(head.decls, buf);
2129 }
2130 }
2131 #[allow(non_camel_case_types)]
2132 pub struct ModuleHeadPtr {
2133 decls: <crate::vec::Vec<ModuledeclsItems> as crate::Encode>::HeadPtr,
2134 }
2135 impl crate::Layout for Module {
2136 fn head_size() -> usize {
2137 64
2138 }
2139 }
2140
2141 impl crate::Decode for Module {
2142 fn decode(buf: &[u8]) -> crate::Result<Self> {
2143 let decls = crate::vec::Vec::<ModuledeclsItems>::decode(buf.skip(0))?;
2144 Ok(Module { decls })
2145 }
2146 }
2147
2148 #[allow(clippy::all, unused_variables)]
2149 impl crate::Encode for ModuledeclsItems {
2150 type HeadPtr = ModuledeclsItemsHeadPtr;
2151 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2152 let name = self.name.encode_head(buf);
2153 let decl = self.decl.encode_head(buf);
2154 ModuledeclsItemsHeadPtr { name, decl }
2155 }
2156 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2157 self.name.encode_body(head.name, buf);
2158 self.decl.encode_body(head.decl, buf);
2159 }
2160 }
2161 #[allow(non_camel_case_types)]
2162 pub struct ModuledeclsItemsHeadPtr {
2163 name: <crate::string::String as crate::Encode>::HeadPtr,
2164 decl: <super::Decl as crate::Encode>::HeadPtr,
2165 }
2166 impl crate::Layout for ModuledeclsItems {
2167 fn head_size() -> usize {
2168 104
2169 }
2170 }
2171
2172 impl crate::Decode for ModuledeclsItems {
2173 fn decode(buf: &[u8]) -> crate::Result<Self> {
2174 let name = crate::string::String::decode(buf.skip(0))?;
2175 let decl = super::Decl::decode(buf.skip(8))?;
2176 Ok(ModuledeclsItems { name, decl })
2177 }
2178 }
2179
2180 #[allow(unused_variables)]
2181 #[allow(clippy::all)]
2182 impl crate::Encode for Decl {
2183 type HeadPtr = DeclHeadPtr;
2184 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> DeclHeadPtr {
2185 match self {
2186 Self::Module(inner) => {
2187 w.put_slice(&[0]);
2188 let head_ptr = crate::ReversePointer::new(w);
2189 let r = DeclHeadPtr::Module(head_ptr);
2190 r
2191 }
2192 Self::Type(inner) => {
2193 w.put_slice(&[1]);
2194 let head_ptr = crate::ReversePointer::new(w);
2195 let r = DeclHeadPtr::Type(head_ptr);
2196 r
2197 }
2198 Self::Var(inner) => {
2199 w.put_slice(&[2]);
2200 let head_ptr = crate::ReversePointer::new(w);
2201 let r = DeclHeadPtr::Var(head_ptr);
2202 r
2203 }
2204 }
2205 }
2206 fn encode_body(&self, head: DeclHeadPtr, w: &mut crate::bytes::BytesMut) {
2207 match self {
2208 Self::Module(inner) => {
2209 let DeclHeadPtr::Module(offset_ptr) = head else {
2210 unreachable!()
2211 };
2212 offset_ptr.write_cur_len(w);
2213 let inner_head_ptr = inner.encode_head(w);
2214 inner.encode_body(inner_head_ptr, w);
2215 }
2216 Self::Type(inner) => {
2217 let DeclHeadPtr::Type(offset_ptr) = head else {
2218 unreachable!()
2219 };
2220 offset_ptr.write_cur_len(w);
2221 let inner_head_ptr = inner.encode_head(w);
2222 inner.encode_body(inner_head_ptr, w);
2223 }
2224 Self::Var(inner) => {
2225 let DeclHeadPtr::Var(offset_ptr) = head else {
2226 unreachable!()
2227 };
2228 offset_ptr.write_cur_len(w);
2229 let inner_head_ptr = inner.encode_head(w);
2230 inner.encode_body(inner_head_ptr, w);
2231 }
2232 }
2233 }
2234 }
2235 #[allow(non_camel_case_types, dead_code)]
2236 pub enum DeclHeadPtr {
2237 None,
2238 Module(crate::ReversePointer),
2239 Type(crate::ReversePointer),
2240 Var(crate::ReversePointer),
2241 }
2242 impl crate::Layout for Decl {
2243 fn head_size() -> usize {
2244 40
2245 }
2246 }
2247
2248 impl crate::Decode for Decl {
2249 fn decode(buf: &[u8]) -> crate::Result<Self> {
2250 let mut tag_bytes = buf.read_n(1).to_vec();
2251 tag_bytes.resize(8, 0);
2252 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
2253 let buf = buf.skip(1);
2254 Ok(match tag {
2255 0 => {
2256 let offset = u32::from_le_bytes(buf.read_const::<4>());
2257 let inner = super::Module::decode(buf.skip(offset as usize))?;
2258 Decl::Module(crate::boxed::Box::new(inner))
2259 }
2260 1 => {
2261 let offset = u32::from_le_bytes(buf.read_const::<4>());
2262 let inner = super::Ty::decode(buf.skip(offset as usize))?;
2263 Decl::Type(inner)
2264 }
2265 2 => {
2266 let offset = u32::from_le_bytes(buf.read_const::<4>());
2267 let inner = super::Ty::decode(buf.skip(offset as usize))?;
2268 Decl::Var(inner)
2269 }
2270 _ => return Err(crate::Error::InvalidData),
2271 })
2272 }
2273 }
2274 }
2275}
2276
2277pub mod br {
2278 #[derive(Debug, Clone)]
2279 #[allow(non_camel_case_types)]
2280 pub struct Program {
2281 pub externals: crate::vec::Vec<ExternalSymbol>,
2282 pub main: Expr,
2283 pub defs: crate::vec::Vec<super::ir::TyDef>,
2284 }
2285
2286 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
2287 #[allow(non_camel_case_types)]
2288 pub struct ExternalSymbol {
2289 pub id: crate::string::String,
2290 pub layout_args: crate::vec::Vec<u32>,
2291 }
2292
2293 #[derive(Debug, Clone)]
2294 #[allow(non_camel_case_types)]
2295 pub struct Expr {
2296 pub kind: ExprKind,
2297 }
2298
2299 #[derive(Debug, Clone, enum_as_inner::EnumAsInner)]
2300 #[allow(non_camel_case_types)]
2301 pub enum ExprKind {
2302 Pointer(Sid),
2303 Literal(crate::vec::Vec<u8>),
2304 Call(crate::boxed::Box<Call>),
2305 Function(crate::boxed::Box<Function>),
2306 Tuple(crate::boxed::Box<Tuple>),
2307 Array(crate::boxed::Box<Array>),
2308 EnumVariant(crate::boxed::Box<EnumVariant>),
2309 EnumEq(crate::boxed::Box<EnumEq>),
2310 Offset(crate::boxed::Box<Offset>),
2311 Deref(crate::boxed::Box<Deref>),
2312 Binding(crate::boxed::Box<Binding>),
2313 Switch(crate::vec::Vec<SwitchBranch>),
2314 }
2315
2316 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
2317 #[allow(non_camel_case_types)]
2318 pub struct Sid(pub u32);
2319
2320 #[derive(Debug, Clone)]
2321 #[allow(non_camel_case_types)]
2322 pub struct Call {
2323 pub function: Expr,
2324 pub args: crate::vec::Vec<Expr>,
2325 }
2326
2327 #[derive(Debug, Clone)]
2328 #[allow(non_camel_case_types)]
2329 pub struct Function {
2330 pub symbol_ns: Sid,
2331 pub body: Expr,
2332 }
2333
2334 #[derive(Debug, Clone)]
2335 #[allow(non_camel_case_types)]
2336 pub struct Tuple {
2337 pub fields: crate::vec::Vec<TupleField>,
2338 pub field_layouts: crate::vec::Vec<TyLayout>,
2339 }
2340
2341 #[derive(Debug, Clone)]
2342 #[allow(non_camel_case_types)]
2343 pub struct TupleField {
2344 pub expr: Expr,
2345 pub unpack: u8,
2346 }
2347
2348 #[derive(Debug, Clone)]
2349 #[allow(non_camel_case_types)]
2350 pub struct Array {
2351 pub item_layout: TyLayout,
2352 pub items: crate::vec::Vec<Expr>,
2353 }
2354
2355 #[derive(Debug, Clone)]
2356 #[allow(non_camel_case_types)]
2357 pub struct EnumVariant {
2358 pub tag: crate::vec::Vec<u8>,
2359 pub inner_bytes: u8,
2360 pub has_ptr: bool,
2361 pub padding_bytes: u8,
2362 pub inner: Expr,
2363 }
2364
2365 #[derive(Debug, Clone)]
2366 #[allow(non_camel_case_types)]
2367 pub struct EnumEq {
2368 pub tag: crate::vec::Vec<u8>,
2369 pub expr: Expr,
2370 }
2371
2372 #[derive(Debug, Clone)]
2373 #[allow(non_camel_case_types)]
2374 pub struct Offset {
2375 pub base: Expr,
2376 pub offset: u32,
2377 }
2378
2379 #[derive(Debug, Clone)]
2380 #[allow(non_camel_case_types)]
2381 pub struct Deref {
2382 pub ptr: Expr,
2383 }
2384
2385 #[derive(Debug, Clone)]
2386 #[allow(non_camel_case_types)]
2387 pub struct Binding {
2388 pub symbol: Sid,
2389 pub expr: Expr,
2390 pub main: Expr,
2391 }
2392
2393 #[derive(Debug, Clone)]
2394 #[allow(non_camel_case_types)]
2395 pub struct SwitchBranch {
2396 pub condition: Expr,
2397 pub value: Expr,
2398 }
2399
2400 #[derive(Debug, Clone, PartialEq, Default)]
2401 #[allow(non_camel_case_types)]
2402 pub struct TyLayout {
2403 pub head_size: u32,
2404 pub body_ptrs: crate::vec::Vec<u32>,
2405 }
2406
2407 mod impls {
2408 #![allow(unused_imports)]
2409 use super::*;
2410 use crate::ReaderExt;
2411 use crate::bytes::BufMut;
2412
2413 #[allow(clippy::all, unused_variables)]
2414 impl crate::Encode for Program {
2415 type HeadPtr = ProgramHeadPtr;
2416 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2417 let externals = self.externals.encode_head(buf);
2418 let main = self.main.encode_head(buf);
2419 let defs = self.defs.encode_head(buf);
2420 ProgramHeadPtr {
2421 externals,
2422 main,
2423 defs,
2424 }
2425 }
2426 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2427 self.externals.encode_body(head.externals, buf);
2428 self.main.encode_body(head.main, buf);
2429 self.defs.encode_body(head.defs, buf);
2430 }
2431 }
2432 #[allow(non_camel_case_types)]
2433 pub struct ProgramHeadPtr {
2434 externals: <crate::vec::Vec<super::ExternalSymbol> as crate::Encode>::HeadPtr,
2435 main: <super::Expr as crate::Encode>::HeadPtr,
2436 defs: <crate::vec::Vec<super::super::ir::TyDef> as crate::Encode>::HeadPtr,
2437 }
2438 impl crate::Layout for Program {
2439 fn head_size() -> usize {
2440 168
2441 }
2442 }
2443
2444 impl crate::Decode for Program {
2445 fn decode(buf: &[u8]) -> crate::Result<Self> {
2446 let externals = crate::vec::Vec::<super::ExternalSymbol>::decode(buf.skip(0))?;
2447 let main = super::Expr::decode(buf.skip(8))?;
2448 let defs = crate::vec::Vec::<super::super::ir::TyDef>::decode(buf.skip(13))?;
2449 Ok(Program {
2450 externals,
2451 main,
2452 defs,
2453 })
2454 }
2455 }
2456
2457 #[allow(clippy::all, unused_variables)]
2458 impl crate::Encode for ExternalSymbol {
2459 type HeadPtr = ExternalSymbolHeadPtr;
2460 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2461 let id = self.id.encode_head(buf);
2462 let layout_args = self.layout_args.encode_head(buf);
2463 ExternalSymbolHeadPtr { id, layout_args }
2464 }
2465 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2466 self.id.encode_body(head.id, buf);
2467 self.layout_args.encode_body(head.layout_args, buf);
2468 }
2469 }
2470 #[allow(non_camel_case_types)]
2471 pub struct ExternalSymbolHeadPtr {
2472 id: <crate::string::String as crate::Encode>::HeadPtr,
2473 layout_args: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
2474 }
2475 impl crate::Layout for ExternalSymbol {
2476 fn head_size() -> usize {
2477 128
2478 }
2479 }
2480
2481 impl crate::Decode for ExternalSymbol {
2482 fn decode(buf: &[u8]) -> crate::Result<Self> {
2483 let id = crate::string::String::decode(buf.skip(0))?;
2484 let layout_args = crate::vec::Vec::<u32>::decode(buf.skip(8))?;
2485 Ok(ExternalSymbol { id, layout_args })
2486 }
2487 }
2488
2489 #[allow(clippy::all, unused_variables)]
2490 impl crate::Encode for Expr {
2491 type HeadPtr = ExprHeadPtr;
2492 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2493 let kind = self.kind.encode_head(buf);
2494 ExprHeadPtr { kind }
2495 }
2496 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2497 self.kind.encode_body(head.kind, buf);
2498 }
2499 }
2500 #[allow(non_camel_case_types)]
2501 pub struct ExprHeadPtr {
2502 kind: <super::ExprKind as crate::Encode>::HeadPtr,
2503 }
2504 impl crate::Layout for Expr {
2505 fn head_size() -> usize {
2506 40
2507 }
2508 }
2509
2510 impl crate::Decode for Expr {
2511 fn decode(buf: &[u8]) -> crate::Result<Self> {
2512 let kind = super::ExprKind::decode(buf.skip(0))?;
2513 Ok(Expr { kind })
2514 }
2515 }
2516
2517 #[allow(unused_variables)]
2518 #[allow(clippy::all)]
2519 impl crate::Encode for ExprKind {
2520 type HeadPtr = ExprKindHeadPtr;
2521 fn encode_head(&self, w: &mut crate::bytes::BytesMut) -> ExprKindHeadPtr {
2522 match self {
2523 Self::Pointer(inner) => {
2524 w.put_slice(&[0]);
2525 let head_ptr = crate::ReversePointer::new(w);
2526 let r = ExprKindHeadPtr::Pointer(head_ptr);
2527 r
2528 }
2529 Self::Literal(inner) => {
2530 w.put_slice(&[1]);
2531 let head_ptr = crate::ReversePointer::new(w);
2532 let r = ExprKindHeadPtr::Literal(head_ptr);
2533 r
2534 }
2535 Self::Call(inner) => {
2536 w.put_slice(&[2]);
2537 let head_ptr = crate::ReversePointer::new(w);
2538 let r = ExprKindHeadPtr::Call(head_ptr);
2539 r
2540 }
2541 Self::Function(inner) => {
2542 w.put_slice(&[3]);
2543 let head_ptr = crate::ReversePointer::new(w);
2544 let r = ExprKindHeadPtr::Function(head_ptr);
2545 r
2546 }
2547 Self::Tuple(inner) => {
2548 w.put_slice(&[4]);
2549 let head_ptr = crate::ReversePointer::new(w);
2550 let r = ExprKindHeadPtr::Tuple(head_ptr);
2551 r
2552 }
2553 Self::Array(inner) => {
2554 w.put_slice(&[5]);
2555 let head_ptr = crate::ReversePointer::new(w);
2556 let r = ExprKindHeadPtr::Array(head_ptr);
2557 r
2558 }
2559 Self::EnumVariant(inner) => {
2560 w.put_slice(&[6]);
2561 let head_ptr = crate::ReversePointer::new(w);
2562 let r = ExprKindHeadPtr::EnumVariant(head_ptr);
2563 r
2564 }
2565 Self::EnumEq(inner) => {
2566 w.put_slice(&[7]);
2567 let head_ptr = crate::ReversePointer::new(w);
2568 let r = ExprKindHeadPtr::EnumEq(head_ptr);
2569 r
2570 }
2571 Self::Offset(inner) => {
2572 w.put_slice(&[8]);
2573 let head_ptr = crate::ReversePointer::new(w);
2574 let r = ExprKindHeadPtr::Offset(head_ptr);
2575 r
2576 }
2577 Self::Deref(inner) => {
2578 w.put_slice(&[9]);
2579 let head_ptr = crate::ReversePointer::new(w);
2580 let r = ExprKindHeadPtr::Deref(head_ptr);
2581 r
2582 }
2583 Self::Binding(inner) => {
2584 w.put_slice(&[10]);
2585 let head_ptr = crate::ReversePointer::new(w);
2586 let r = ExprKindHeadPtr::Binding(head_ptr);
2587 r
2588 }
2589 Self::Switch(inner) => {
2590 w.put_slice(&[11]);
2591 let head_ptr = crate::ReversePointer::new(w);
2592 let r = ExprKindHeadPtr::Switch(head_ptr);
2593 r
2594 }
2595 }
2596 }
2597 fn encode_body(&self, head: ExprKindHeadPtr, w: &mut crate::bytes::BytesMut) {
2598 match self {
2599 Self::Pointer(inner) => {
2600 let ExprKindHeadPtr::Pointer(offset_ptr) = head else {
2601 unreachable!()
2602 };
2603 offset_ptr.write_cur_len(w);
2604 let inner_head_ptr = inner.encode_head(w);
2605 inner.encode_body(inner_head_ptr, w);
2606 }
2607 Self::Literal(inner) => {
2608 let ExprKindHeadPtr::Literal(offset_ptr) = head else {
2609 unreachable!()
2610 };
2611 offset_ptr.write_cur_len(w);
2612 let inner_head_ptr = inner.encode_head(w);
2613 inner.encode_body(inner_head_ptr, w);
2614 }
2615 Self::Call(inner) => {
2616 let ExprKindHeadPtr::Call(offset_ptr) = head else {
2617 unreachable!()
2618 };
2619 offset_ptr.write_cur_len(w);
2620 let inner_head_ptr = inner.encode_head(w);
2621 inner.encode_body(inner_head_ptr, w);
2622 }
2623 Self::Function(inner) => {
2624 let ExprKindHeadPtr::Function(offset_ptr) = head else {
2625 unreachable!()
2626 };
2627 offset_ptr.write_cur_len(w);
2628 let inner_head_ptr = inner.encode_head(w);
2629 inner.encode_body(inner_head_ptr, w);
2630 }
2631 Self::Tuple(inner) => {
2632 let ExprKindHeadPtr::Tuple(offset_ptr) = head else {
2633 unreachable!()
2634 };
2635 offset_ptr.write_cur_len(w);
2636 let inner_head_ptr = inner.encode_head(w);
2637 inner.encode_body(inner_head_ptr, w);
2638 }
2639 Self::Array(inner) => {
2640 let ExprKindHeadPtr::Array(offset_ptr) = head else {
2641 unreachable!()
2642 };
2643 offset_ptr.write_cur_len(w);
2644 let inner_head_ptr = inner.encode_head(w);
2645 inner.encode_body(inner_head_ptr, w);
2646 }
2647 Self::EnumVariant(inner) => {
2648 let ExprKindHeadPtr::EnumVariant(offset_ptr) = head else {
2649 unreachable!()
2650 };
2651 offset_ptr.write_cur_len(w);
2652 let inner_head_ptr = inner.encode_head(w);
2653 inner.encode_body(inner_head_ptr, w);
2654 }
2655 Self::EnumEq(inner) => {
2656 let ExprKindHeadPtr::EnumEq(offset_ptr) = head else {
2657 unreachable!()
2658 };
2659 offset_ptr.write_cur_len(w);
2660 let inner_head_ptr = inner.encode_head(w);
2661 inner.encode_body(inner_head_ptr, w);
2662 }
2663 Self::Offset(inner) => {
2664 let ExprKindHeadPtr::Offset(offset_ptr) = head else {
2665 unreachable!()
2666 };
2667 offset_ptr.write_cur_len(w);
2668 let inner_head_ptr = inner.encode_head(w);
2669 inner.encode_body(inner_head_ptr, w);
2670 }
2671 Self::Deref(inner) => {
2672 let ExprKindHeadPtr::Deref(offset_ptr) = head else {
2673 unreachable!()
2674 };
2675 offset_ptr.write_cur_len(w);
2676 let inner_head_ptr = inner.encode_head(w);
2677 inner.encode_body(inner_head_ptr, w);
2678 }
2679 Self::Binding(inner) => {
2680 let ExprKindHeadPtr::Binding(offset_ptr) = head else {
2681 unreachable!()
2682 };
2683 offset_ptr.write_cur_len(w);
2684 let inner_head_ptr = inner.encode_head(w);
2685 inner.encode_body(inner_head_ptr, w);
2686 }
2687 Self::Switch(inner) => {
2688 let ExprKindHeadPtr::Switch(offset_ptr) = head else {
2689 unreachable!()
2690 };
2691 offset_ptr.write_cur_len(w);
2692 let inner_head_ptr = inner.encode_head(w);
2693 inner.encode_body(inner_head_ptr, w);
2694 }
2695 }
2696 }
2697 }
2698 #[allow(non_camel_case_types, dead_code)]
2699 pub enum ExprKindHeadPtr {
2700 None,
2701 Pointer(crate::ReversePointer),
2702 Literal(crate::ReversePointer),
2703 Call(crate::ReversePointer),
2704 Function(crate::ReversePointer),
2705 Tuple(crate::ReversePointer),
2706 Array(crate::ReversePointer),
2707 EnumVariant(crate::ReversePointer),
2708 EnumEq(crate::ReversePointer),
2709 Offset(crate::ReversePointer),
2710 Deref(crate::ReversePointer),
2711 Binding(crate::ReversePointer),
2712 Switch(crate::ReversePointer),
2713 }
2714 impl crate::Layout for ExprKind {
2715 fn head_size() -> usize {
2716 40
2717 }
2718 }
2719
2720 impl crate::Decode for ExprKind {
2721 fn decode(buf: &[u8]) -> crate::Result<Self> {
2722 let mut tag_bytes = buf.read_n(1).to_vec();
2723 tag_bytes.resize(8, 0);
2724 let tag = u64::from_le_bytes(tag_bytes.try_into().unwrap()) as usize;
2725 let buf = buf.skip(1);
2726 Ok(match tag {
2727 0 => {
2728 let offset = u32::from_le_bytes(buf.read_const::<4>());
2729 let inner = super::Sid::decode(buf.skip(offset as usize))?;
2730 ExprKind::Pointer(inner)
2731 }
2732 1 => {
2733 let offset = u32::from_le_bytes(buf.read_const::<4>());
2734 let inner = crate::vec::Vec::<u8>::decode(buf.skip(offset as usize))?;
2735 ExprKind::Literal(inner)
2736 }
2737 2 => {
2738 let offset = u32::from_le_bytes(buf.read_const::<4>());
2739 let inner = super::Call::decode(buf.skip(offset as usize))?;
2740 ExprKind::Call(crate::boxed::Box::new(inner))
2741 }
2742 3 => {
2743 let offset = u32::from_le_bytes(buf.read_const::<4>());
2744 let inner = super::Function::decode(buf.skip(offset as usize))?;
2745 ExprKind::Function(crate::boxed::Box::new(inner))
2746 }
2747 4 => {
2748 let offset = u32::from_le_bytes(buf.read_const::<4>());
2749 let inner = super::Tuple::decode(buf.skip(offset as usize))?;
2750 ExprKind::Tuple(crate::boxed::Box::new(inner))
2751 }
2752 5 => {
2753 let offset = u32::from_le_bytes(buf.read_const::<4>());
2754 let inner = super::Array::decode(buf.skip(offset as usize))?;
2755 ExprKind::Array(crate::boxed::Box::new(inner))
2756 }
2757 6 => {
2758 let offset = u32::from_le_bytes(buf.read_const::<4>());
2759 let inner = super::EnumVariant::decode(buf.skip(offset as usize))?;
2760 ExprKind::EnumVariant(crate::boxed::Box::new(inner))
2761 }
2762 7 => {
2763 let offset = u32::from_le_bytes(buf.read_const::<4>());
2764 let inner = super::EnumEq::decode(buf.skip(offset as usize))?;
2765 ExprKind::EnumEq(crate::boxed::Box::new(inner))
2766 }
2767 8 => {
2768 let offset = u32::from_le_bytes(buf.read_const::<4>());
2769 let inner = super::Offset::decode(buf.skip(offset as usize))?;
2770 ExprKind::Offset(crate::boxed::Box::new(inner))
2771 }
2772 9 => {
2773 let offset = u32::from_le_bytes(buf.read_const::<4>());
2774 let inner = super::Deref::decode(buf.skip(offset as usize))?;
2775 ExprKind::Deref(crate::boxed::Box::new(inner))
2776 }
2777 10 => {
2778 let offset = u32::from_le_bytes(buf.read_const::<4>());
2779 let inner = super::Binding::decode(buf.skip(offset as usize))?;
2780 ExprKind::Binding(crate::boxed::Box::new(inner))
2781 }
2782 11 => {
2783 let offset = u32::from_le_bytes(buf.read_const::<4>());
2784 let inner = crate::vec::Vec::<super::SwitchBranch>::decode(
2785 buf.skip(offset as usize),
2786 )?;
2787 ExprKind::Switch(inner)
2788 }
2789 _ => return Err(crate::Error::InvalidData),
2790 })
2791 }
2792 }
2793
2794 impl crate::Encode for Sid {
2795 type HeadPtr = ();
2796 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) {
2797 self.0.encode_head(buf)
2798 }
2799 fn encode_body(&self, _: (), _: &mut crate::bytes::BytesMut) {}
2800 }
2801 impl crate::Layout for Sid {
2802 fn head_size() -> usize {
2803 32
2804 }
2805 }
2806
2807 impl crate::Decode for Sid {
2808 fn decode(buf: &[u8]) -> crate::Result<Self> {
2809 Ok(Self(u32::decode(buf)?))
2810 }
2811 }
2812
2813 #[allow(clippy::all, unused_variables)]
2814 impl crate::Encode for Call {
2815 type HeadPtr = CallHeadPtr;
2816 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2817 let function = self.function.encode_head(buf);
2818 let args = self.args.encode_head(buf);
2819 CallHeadPtr { function, args }
2820 }
2821 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2822 self.function.encode_body(head.function, buf);
2823 self.args.encode_body(head.args, buf);
2824 }
2825 }
2826 #[allow(non_camel_case_types)]
2827 pub struct CallHeadPtr {
2828 function: <super::Expr as crate::Encode>::HeadPtr,
2829 args: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
2830 }
2831 impl crate::Layout for Call {
2832 fn head_size() -> usize {
2833 104
2834 }
2835 }
2836
2837 impl crate::Decode for Call {
2838 fn decode(buf: &[u8]) -> crate::Result<Self> {
2839 let function = super::Expr::decode(buf.skip(0))?;
2840 let args = crate::vec::Vec::<super::Expr>::decode(buf.skip(5))?;
2841 Ok(Call { function, args })
2842 }
2843 }
2844
2845 #[allow(clippy::all, unused_variables)]
2846 impl crate::Encode for Function {
2847 type HeadPtr = FunctionHeadPtr;
2848 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2849 let symbol_ns = self.symbol_ns.encode_head(buf);
2850 let body = self.body.encode_head(buf);
2851 FunctionHeadPtr { symbol_ns, body }
2852 }
2853 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2854 self.symbol_ns.encode_body(head.symbol_ns, buf);
2855 self.body.encode_body(head.body, buf);
2856 }
2857 }
2858 #[allow(non_camel_case_types)]
2859 pub struct FunctionHeadPtr {
2860 symbol_ns: <super::Sid as crate::Encode>::HeadPtr,
2861 body: <super::Expr as crate::Encode>::HeadPtr,
2862 }
2863 impl crate::Layout for Function {
2864 fn head_size() -> usize {
2865 72
2866 }
2867 }
2868
2869 impl crate::Decode for Function {
2870 fn decode(buf: &[u8]) -> crate::Result<Self> {
2871 let symbol_ns = super::Sid::decode(buf.skip(0))?;
2872 let body = super::Expr::decode(buf.skip(4))?;
2873 Ok(Function { symbol_ns, body })
2874 }
2875 }
2876
2877 #[allow(clippy::all, unused_variables)]
2878 impl crate::Encode for Tuple {
2879 type HeadPtr = TupleHeadPtr;
2880 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2881 let fields = self.fields.encode_head(buf);
2882 let field_layouts = self.field_layouts.encode_head(buf);
2883 TupleHeadPtr {
2884 fields,
2885 field_layouts,
2886 }
2887 }
2888 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2889 self.fields.encode_body(head.fields, buf);
2890 self.field_layouts.encode_body(head.field_layouts, buf);
2891 }
2892 }
2893 #[allow(non_camel_case_types)]
2894 pub struct TupleHeadPtr {
2895 fields: <crate::vec::Vec<super::TupleField> as crate::Encode>::HeadPtr,
2896 field_layouts: <crate::vec::Vec<super::TyLayout> as crate::Encode>::HeadPtr,
2897 }
2898 impl crate::Layout for Tuple {
2899 fn head_size() -> usize {
2900 128
2901 }
2902 }
2903
2904 impl crate::Decode for Tuple {
2905 fn decode(buf: &[u8]) -> crate::Result<Self> {
2906 let fields = crate::vec::Vec::<super::TupleField>::decode(buf.skip(0))?;
2907 let field_layouts = crate::vec::Vec::<super::TyLayout>::decode(buf.skip(8))?;
2908 Ok(Tuple {
2909 fields,
2910 field_layouts,
2911 })
2912 }
2913 }
2914
2915 #[allow(clippy::all, unused_variables)]
2916 impl crate::Encode for TupleField {
2917 type HeadPtr = TupleFieldHeadPtr;
2918 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2919 let expr = self.expr.encode_head(buf);
2920 let unpack = self.unpack.encode_head(buf);
2921 TupleFieldHeadPtr { expr, unpack }
2922 }
2923 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2924 self.expr.encode_body(head.expr, buf);
2925 self.unpack.encode_body(head.unpack, buf);
2926 }
2927 }
2928 #[allow(non_camel_case_types)]
2929 pub struct TupleFieldHeadPtr {
2930 expr: <super::Expr as crate::Encode>::HeadPtr,
2931 unpack: <u8 as crate::Encode>::HeadPtr,
2932 }
2933 impl crate::Layout for TupleField {
2934 fn head_size() -> usize {
2935 48
2936 }
2937 }
2938
2939 impl crate::Decode for TupleField {
2940 fn decode(buf: &[u8]) -> crate::Result<Self> {
2941 let expr = super::Expr::decode(buf.skip(0))?;
2942 let unpack = u8::decode(buf.skip(5))?;
2943 Ok(TupleField { expr, unpack })
2944 }
2945 }
2946
2947 #[allow(clippy::all, unused_variables)]
2948 impl crate::Encode for Array {
2949 type HeadPtr = ArrayHeadPtr;
2950 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2951 let item_layout = self.item_layout.encode_head(buf);
2952 let items = self.items.encode_head(buf);
2953 ArrayHeadPtr { item_layout, items }
2954 }
2955 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2956 self.item_layout.encode_body(head.item_layout, buf);
2957 self.items.encode_body(head.items, buf);
2958 }
2959 }
2960 #[allow(non_camel_case_types)]
2961 pub struct ArrayHeadPtr {
2962 item_layout: <super::TyLayout as crate::Encode>::HeadPtr,
2963 items: <crate::vec::Vec<super::Expr> as crate::Encode>::HeadPtr,
2964 }
2965 impl crate::Layout for Array {
2966 fn head_size() -> usize {
2967 160
2968 }
2969 }
2970
2971 impl crate::Decode for Array {
2972 fn decode(buf: &[u8]) -> crate::Result<Self> {
2973 let item_layout = super::TyLayout::decode(buf.skip(0))?;
2974 let items = crate::vec::Vec::<super::Expr>::decode(buf.skip(12))?;
2975 Ok(Array { item_layout, items })
2976 }
2977 }
2978
2979 #[allow(clippy::all, unused_variables)]
2980 impl crate::Encode for EnumVariant {
2981 type HeadPtr = EnumVariantHeadPtr;
2982 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
2983 let tag = self.tag.encode_head(buf);
2984 let inner_bytes = self.inner_bytes.encode_head(buf);
2985 let has_ptr = self.has_ptr.encode_head(buf);
2986 let padding_bytes = self.padding_bytes.encode_head(buf);
2987 let inner = self.inner.encode_head(buf);
2988 EnumVariantHeadPtr {
2989 tag,
2990 inner_bytes,
2991 has_ptr,
2992 padding_bytes,
2993 inner,
2994 }
2995 }
2996 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
2997 self.tag.encode_body(head.tag, buf);
2998 self.inner_bytes.encode_body(head.inner_bytes, buf);
2999 self.has_ptr.encode_body(head.has_ptr, buf);
3000 self.padding_bytes.encode_body(head.padding_bytes, buf);
3001 self.inner.encode_body(head.inner, buf);
3002 }
3003 }
3004 #[allow(non_camel_case_types)]
3005 pub struct EnumVariantHeadPtr {
3006 tag: <crate::vec::Vec<u8> as crate::Encode>::HeadPtr,
3007 inner_bytes: <u8 as crate::Encode>::HeadPtr,
3008 has_ptr: <bool as crate::Encode>::HeadPtr,
3009 padding_bytes: <u8 as crate::Encode>::HeadPtr,
3010 inner: <super::Expr as crate::Encode>::HeadPtr,
3011 }
3012 impl crate::Layout for EnumVariant {
3013 fn head_size() -> usize {
3014 128
3015 }
3016 }
3017
3018 impl crate::Decode for EnumVariant {
3019 fn decode(buf: &[u8]) -> crate::Result<Self> {
3020 let tag = crate::vec::Vec::<u8>::decode(buf.skip(0))?;
3021 let inner_bytes = u8::decode(buf.skip(8))?;
3022 let has_ptr = bool::decode(buf.skip(9))?;
3023 let padding_bytes = u8::decode(buf.skip(10))?;
3024 let inner = super::Expr::decode(buf.skip(11))?;
3025 Ok(EnumVariant {
3026 tag,
3027 inner_bytes,
3028 has_ptr,
3029 padding_bytes,
3030 inner,
3031 })
3032 }
3033 }
3034
3035 #[allow(clippy::all, unused_variables)]
3036 impl crate::Encode for EnumEq {
3037 type HeadPtr = EnumEqHeadPtr;
3038 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3039 let tag = self.tag.encode_head(buf);
3040 let expr = self.expr.encode_head(buf);
3041 EnumEqHeadPtr { tag, expr }
3042 }
3043 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3044 self.tag.encode_body(head.tag, buf);
3045 self.expr.encode_body(head.expr, buf);
3046 }
3047 }
3048 #[allow(non_camel_case_types)]
3049 pub struct EnumEqHeadPtr {
3050 tag: <crate::vec::Vec<u8> as crate::Encode>::HeadPtr,
3051 expr: <super::Expr as crate::Encode>::HeadPtr,
3052 }
3053 impl crate::Layout for EnumEq {
3054 fn head_size() -> usize {
3055 104
3056 }
3057 }
3058
3059 impl crate::Decode for EnumEq {
3060 fn decode(buf: &[u8]) -> crate::Result<Self> {
3061 let tag = crate::vec::Vec::<u8>::decode(buf.skip(0))?;
3062 let expr = super::Expr::decode(buf.skip(8))?;
3063 Ok(EnumEq { tag, expr })
3064 }
3065 }
3066
3067 #[allow(clippy::all, unused_variables)]
3068 impl crate::Encode for Offset {
3069 type HeadPtr = OffsetHeadPtr;
3070 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3071 let base = self.base.encode_head(buf);
3072 let offset = self.offset.encode_head(buf);
3073 OffsetHeadPtr { base, offset }
3074 }
3075 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3076 self.base.encode_body(head.base, buf);
3077 self.offset.encode_body(head.offset, buf);
3078 }
3079 }
3080 #[allow(non_camel_case_types)]
3081 pub struct OffsetHeadPtr {
3082 base: <super::Expr as crate::Encode>::HeadPtr,
3083 offset: <u32 as crate::Encode>::HeadPtr,
3084 }
3085 impl crate::Layout for Offset {
3086 fn head_size() -> usize {
3087 72
3088 }
3089 }
3090
3091 impl crate::Decode for Offset {
3092 fn decode(buf: &[u8]) -> crate::Result<Self> {
3093 let base = super::Expr::decode(buf.skip(0))?;
3094 let offset = u32::decode(buf.skip(5))?;
3095 Ok(Offset { base, offset })
3096 }
3097 }
3098
3099 #[allow(clippy::all, unused_variables)]
3100 impl crate::Encode for Deref {
3101 type HeadPtr = DerefHeadPtr;
3102 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3103 let ptr = self.ptr.encode_head(buf);
3104 DerefHeadPtr { ptr }
3105 }
3106 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3107 self.ptr.encode_body(head.ptr, buf);
3108 }
3109 }
3110 #[allow(non_camel_case_types)]
3111 pub struct DerefHeadPtr {
3112 ptr: <super::Expr as crate::Encode>::HeadPtr,
3113 }
3114 impl crate::Layout for Deref {
3115 fn head_size() -> usize {
3116 40
3117 }
3118 }
3119
3120 impl crate::Decode for Deref {
3121 fn decode(buf: &[u8]) -> crate::Result<Self> {
3122 let ptr = super::Expr::decode(buf.skip(0))?;
3123 Ok(Deref { ptr })
3124 }
3125 }
3126
3127 #[allow(clippy::all, unused_variables)]
3128 impl crate::Encode for Binding {
3129 type HeadPtr = BindingHeadPtr;
3130 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3131 let symbol = self.symbol.encode_head(buf);
3132 let expr = self.expr.encode_head(buf);
3133 let main = self.main.encode_head(buf);
3134 BindingHeadPtr { symbol, expr, main }
3135 }
3136 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3137 self.symbol.encode_body(head.symbol, buf);
3138 self.expr.encode_body(head.expr, buf);
3139 self.main.encode_body(head.main, buf);
3140 }
3141 }
3142 #[allow(non_camel_case_types)]
3143 pub struct BindingHeadPtr {
3144 symbol: <super::Sid as crate::Encode>::HeadPtr,
3145 expr: <super::Expr as crate::Encode>::HeadPtr,
3146 main: <super::Expr as crate::Encode>::HeadPtr,
3147 }
3148 impl crate::Layout for Binding {
3149 fn head_size() -> usize {
3150 112
3151 }
3152 }
3153
3154 impl crate::Decode for Binding {
3155 fn decode(buf: &[u8]) -> crate::Result<Self> {
3156 let symbol = super::Sid::decode(buf.skip(0))?;
3157 let expr = super::Expr::decode(buf.skip(4))?;
3158 let main = super::Expr::decode(buf.skip(9))?;
3159 Ok(Binding { symbol, expr, main })
3160 }
3161 }
3162
3163 #[allow(clippy::all, unused_variables)]
3164 impl crate::Encode for SwitchBranch {
3165 type HeadPtr = SwitchBranchHeadPtr;
3166 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3167 let condition = self.condition.encode_head(buf);
3168 let value = self.value.encode_head(buf);
3169 SwitchBranchHeadPtr { condition, value }
3170 }
3171 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3172 self.condition.encode_body(head.condition, buf);
3173 self.value.encode_body(head.value, buf);
3174 }
3175 }
3176 #[allow(non_camel_case_types)]
3177 pub struct SwitchBranchHeadPtr {
3178 condition: <super::Expr as crate::Encode>::HeadPtr,
3179 value: <super::Expr as crate::Encode>::HeadPtr,
3180 }
3181 impl crate::Layout for SwitchBranch {
3182 fn head_size() -> usize {
3183 80
3184 }
3185 }
3186
3187 impl crate::Decode for SwitchBranch {
3188 fn decode(buf: &[u8]) -> crate::Result<Self> {
3189 let condition = super::Expr::decode(buf.skip(0))?;
3190 let value = super::Expr::decode(buf.skip(5))?;
3191 Ok(SwitchBranch { condition, value })
3192 }
3193 }
3194
3195 #[allow(clippy::all, unused_variables)]
3196 impl crate::Encode for TyLayout {
3197 type HeadPtr = TyLayoutHeadPtr;
3198 fn encode_head(&self, buf: &mut crate::bytes::BytesMut) -> Self::HeadPtr {
3199 let head_size = self.head_size.encode_head(buf);
3200 let body_ptrs = self.body_ptrs.encode_head(buf);
3201 TyLayoutHeadPtr {
3202 head_size,
3203 body_ptrs,
3204 }
3205 }
3206 fn encode_body(&self, head: Self::HeadPtr, buf: &mut crate::bytes::BytesMut) {
3207 self.head_size.encode_body(head.head_size, buf);
3208 self.body_ptrs.encode_body(head.body_ptrs, buf);
3209 }
3210 }
3211 #[allow(non_camel_case_types)]
3212 pub struct TyLayoutHeadPtr {
3213 head_size: <u32 as crate::Encode>::HeadPtr,
3214 body_ptrs: <crate::vec::Vec<u32> as crate::Encode>::HeadPtr,
3215 }
3216 impl crate::Layout for TyLayout {
3217 fn head_size() -> usize {
3218 96
3219 }
3220 }
3221
3222 impl crate::Decode for TyLayout {
3223 fn decode(buf: &[u8]) -> crate::Result<Self> {
3224 let head_size = u32::decode(buf.skip(0))?;
3225 let body_ptrs = crate::vec::Vec::<u32>::decode(buf.skip(4))?;
3226 Ok(TyLayout {
3227 head_size,
3228 body_ptrs,
3229 })
3230 }
3231 }
3232 }
3233}