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