1//! Conversions from `wasmparser` to `wasm-encoder` to [`Reencode`] parsed wasm.
2//!
3//! The [`RoundtripReencoder`] allows encoding identical wasm to the parsed
4//! input.
5
6#[cfg(all(not(feature = "std"), core_error))]
7use core::error::Error as StdError;
8#[cfg(feature = "std")]
9use std::error::Error as StdError;
10
11use crate::CoreTypeEncoder;
12use core::convert::Infallible;
13
14#[cfg(feature = "component-model")]
15mod component;
16
17#[cfg(feature = "component-model")]
18pub use self::component::*;
19
20#[allow(missing_docs)] // FIXME
21pub trait Reencode {
22 type Error;
23
24 fn data_index(&mut self, data: u32) -> u32 {
25 utils::data_index(self, data)
26 }
27
28 fn element_index(&mut self, element: u32) -> u32 {
29 utils::element_index(self, element)
30 }
31
32 fn function_index(&mut self, func: u32) -> u32 {
33 utils::function_index(self, func)
34 }
35
36 fn global_index(&mut self, global: u32) -> u32 {
37 utils::global_index(self, global)
38 }
39
40 fn memory_index(&mut self, memory: u32) -> u32 {
41 utils::memory_index(self, memory)
42 }
43
44 fn table_index(&mut self, table: u32) -> u32 {
45 utils::table_index(self, table)
46 }
47
48 fn tag_index(&mut self, tag: u32) -> u32 {
49 utils::tag_index(self, tag)
50 }
51
52 fn type_index(&mut self, ty: u32) -> u32 {
53 utils::type_index(self, ty)
54 }
55
56 fn type_index_unpacked(
57 &mut self,
58 ty: wasmparser::UnpackedIndex,
59 ) -> Result<u32, Error<Self::Error>> {
60 utils::type_index_unpacked(self, ty)
61 }
62
63 fn external_index(&mut self, kind: wasmparser::ExternalKind, index: u32) -> u32 {
64 match kind {
65 wasmparser::ExternalKind::Func => self.function_index(index),
66 wasmparser::ExternalKind::Table => self.table_index(index),
67 wasmparser::ExternalKind::Memory => self.memory_index(index),
68 wasmparser::ExternalKind::Global => self.global_index(index),
69 wasmparser::ExternalKind::Tag => self.tag_index(index),
70 }
71 }
72
73 fn abstract_heap_type(
74 &mut self,
75 value: wasmparser::AbstractHeapType,
76 ) -> crate::AbstractHeapType {
77 utils::abstract_heap_type(self, value)
78 }
79
80 fn array_type(
81 &mut self,
82 array_ty: wasmparser::ArrayType,
83 ) -> Result<crate::ArrayType, Error<Self::Error>> {
84 utils::array_type(self, array_ty)
85 }
86
87 fn block_type(
88 &mut self,
89 arg: wasmparser::BlockType,
90 ) -> Result<crate::BlockType, Error<Self::Error>> {
91 utils::block_type(self, arg)
92 }
93
94 fn const_expr(
95 &mut self,
96 const_expr: wasmparser::ConstExpr,
97 ) -> Result<crate::ConstExpr, Error<Self::Error>> {
98 utils::const_expr(self, const_expr)
99 }
100
101 fn catch(&mut self, arg: wasmparser::Catch) -> crate::Catch {
102 utils::catch(self, arg)
103 }
104
105 fn composite_type(
106 &mut self,
107 composite_ty: wasmparser::CompositeType,
108 ) -> Result<crate::CompositeType, Error<Self::Error>> {
109 utils::composite_type(self, composite_ty)
110 }
111
112 fn entity_type(
113 &mut self,
114 type_ref: wasmparser::TypeRef,
115 ) -> Result<crate::EntityType, Error<Self::Error>> {
116 utils::entity_type(self, type_ref)
117 }
118
119 fn export_kind(&mut self, external_kind: wasmparser::ExternalKind) -> crate::ExportKind {
120 utils::export_kind(self, external_kind)
121 }
122
123 fn field_type(
124 &mut self,
125 field_ty: wasmparser::FieldType,
126 ) -> Result<crate::FieldType, Error<Self::Error>> {
127 utils::field_type(self, field_ty)
128 }
129
130 fn func_type(
131 &mut self,
132 func_ty: wasmparser::FuncType,
133 ) -> Result<crate::FuncType, Error<Self::Error>> {
134 utils::func_type(self, func_ty)
135 }
136
137 fn cont_type(
138 &mut self,
139 cont_ty: wasmparser::ContType,
140 ) -> Result<crate::ContType, Error<Self::Error>> {
141 utils::cont_type(self, cont_ty)
142 }
143
144 fn global_type(
145 &mut self,
146 global_ty: wasmparser::GlobalType,
147 ) -> Result<crate::GlobalType, Error<Self::Error>> {
148 utils::global_type(self, global_ty)
149 }
150
151 fn handle(&mut self, on: wasmparser::Handle) -> crate::Handle {
152 utils::handle(self, on)
153 }
154
155 fn heap_type(
156 &mut self,
157 heap_type: wasmparser::HeapType,
158 ) -> Result<crate::HeapType, Error<Self::Error>> {
159 utils::heap_type(self, heap_type)
160 }
161
162 fn instruction<'a>(
163 &mut self,
164 arg: wasmparser::Operator<'a>,
165 ) -> Result<crate::Instruction<'a>, Error<Self::Error>> {
166 utils::instruction(self, arg)
167 }
168
169 fn memory_type(&mut self, memory_ty: wasmparser::MemoryType) -> crate::MemoryType {
170 utils::memory_type(self, memory_ty)
171 }
172
173 fn mem_arg(&mut self, arg: wasmparser::MemArg) -> crate::MemArg {
174 utils::mem_arg(self, arg)
175 }
176
177 fn ordering(&mut self, arg: wasmparser::Ordering) -> crate::Ordering {
178 utils::ordering(self, arg)
179 }
180
181 fn ref_type(
182 &mut self,
183 ref_type: wasmparser::RefType,
184 ) -> Result<crate::RefType, Error<Self::Error>> {
185 utils::ref_type(self, ref_type)
186 }
187
188 fn storage_type(
189 &mut self,
190 storage_ty: wasmparser::StorageType,
191 ) -> Result<crate::StorageType, Error<Self::Error>> {
192 utils::storage_type(self, storage_ty)
193 }
194
195 fn struct_type(
196 &mut self,
197 struct_ty: wasmparser::StructType,
198 ) -> Result<crate::StructType, Error<Self::Error>> {
199 utils::struct_type(self, struct_ty)
200 }
201
202 fn sub_type(
203 &mut self,
204 sub_ty: wasmparser::SubType,
205 ) -> Result<crate::SubType, Error<Self::Error>> {
206 utils::sub_type(self, sub_ty)
207 }
208
209 fn table_type(
210 &mut self,
211 table_ty: wasmparser::TableType,
212 ) -> Result<crate::TableType, Error<Self::Error>> {
213 utils::table_type(self, table_ty)
214 }
215
216 fn tag_kind(&mut self, kind: wasmparser::TagKind) -> crate::TagKind {
217 utils::tag_kind(self, kind)
218 }
219
220 fn tag_type(&mut self, tag_ty: wasmparser::TagType) -> crate::TagType {
221 utils::tag_type(self, tag_ty)
222 }
223
224 fn val_type(
225 &mut self,
226 val_ty: wasmparser::ValType,
227 ) -> Result<crate::ValType, Error<Self::Error>> {
228 utils::val_type(self, val_ty)
229 }
230
231 /// Parses the input `section` given from the `wasmparser` crate and
232 /// adds the custom section to the `module`.
233 fn parse_custom_section(
234 &mut self,
235 module: &mut crate::Module,
236 section: wasmparser::CustomSectionReader<'_>,
237 ) -> Result<(), Error<Self::Error>> {
238 utils::parse_custom_section(self, module, section)
239 }
240
241 /// Converts the input `section` given from the `wasmparser` crate into an
242 /// encoded custom section.
243 fn custom_section<'a>(
244 &mut self,
245 section: wasmparser::CustomSectionReader<'a>,
246 ) -> crate::CustomSection<'a> {
247 utils::custom_section(self, section)
248 }
249
250 /// Parses the input `section` given from the `wasmparser` crate and adds
251 /// all the code to the `code` section.
252 fn parse_code_section(
253 &mut self,
254 code: &mut crate::CodeSection,
255 section: wasmparser::CodeSectionReader<'_>,
256 ) -> Result<(), Error<Self::Error>> {
257 utils::parse_code_section(self, code, section)
258 }
259
260 /// Parses a single [`wasmparser::FunctionBody`] and adds it to the `code` section.
261 fn parse_function_body(
262 &mut self,
263 code: &mut crate::CodeSection,
264 func: wasmparser::FunctionBody<'_>,
265 ) -> Result<(), Error<Self::Error>> {
266 utils::parse_function_body(self, code, func)
267 }
268
269 /// Create a new [`crate::Function`] by parsing the locals declarations from the
270 /// provided [`wasmparser::FunctionBody`].
271 fn new_function_with_parsed_locals(
272 &mut self,
273 func: &wasmparser::FunctionBody<'_>,
274 ) -> Result<crate::Function, Error<Self::Error>> {
275 utils::new_function_with_parsed_locals(self, func)
276 }
277
278 /// Parses a single instruction from `reader` and adds it to `function`.
279 fn parse_instruction<'a>(
280 &mut self,
281 reader: &mut wasmparser::OperatorsReader<'a>,
282 ) -> Result<crate::Instruction<'a>, Error<Self::Error>> {
283 utils::parse_instruction(self, reader)
284 }
285
286 /// Parses the input `section` given from the `wasmparser` crate and adds
287 /// all the data to the `data` section.
288 fn parse_data_section(
289 &mut self,
290 data: &mut crate::DataSection,
291 section: wasmparser::DataSectionReader<'_>,
292 ) -> Result<(), Error<Self::Error>> {
293 utils::parse_data_section(self, data, section)
294 }
295
296 /// Parses a single [`wasmparser::Data`] and adds it to the `data` section.
297 fn parse_data(
298 &mut self,
299 data: &mut crate::DataSection,
300 datum: wasmparser::Data<'_>,
301 ) -> Result<(), Error<Self::Error>> {
302 utils::parse_data(self, data, datum)
303 }
304
305 /// Parses the input `section` given from the `wasmparser` crate and adds
306 /// all the elements to the `element` section.
307 fn parse_element_section(
308 &mut self,
309 elements: &mut crate::ElementSection,
310 section: wasmparser::ElementSectionReader<'_>,
311 ) -> Result<(), Error<Self::Error>> {
312 utils::parse_element_section(self, elements, section)
313 }
314
315 /// Parses the single [`wasmparser::Element`] provided and adds it to the
316 /// `element` section.
317 fn parse_element(
318 &mut self,
319 elements: &mut crate::ElementSection,
320 element: wasmparser::Element<'_>,
321 ) -> Result<(), Error<Self::Error>> {
322 utils::parse_element(self, elements, element)
323 }
324
325 fn element_items<'a>(
326 &mut self,
327 items: wasmparser::ElementItems<'a>,
328 ) -> Result<crate::Elements<'a>, Error<Self::Error>> {
329 utils::element_items(self, items)
330 }
331
332 /// Parses the input `section` given from the `wasmparser` crate and adds
333 /// all the exports to the `exports` section.
334 fn parse_export_section(
335 &mut self,
336 exports: &mut crate::ExportSection,
337 section: wasmparser::ExportSectionReader<'_>,
338 ) -> Result<(), Error<Self::Error>> {
339 utils::parse_export_section(self, exports, section)
340 }
341
342 /// Parses the single [`wasmparser::Export`] provided and adds it to the
343 /// `exports` section.
344 fn parse_export(&mut self, exports: &mut crate::ExportSection, export: wasmparser::Export<'_>) {
345 utils::parse_export(self, exports, export)
346 }
347
348 /// Parses the input `section` given from the `wasmparser` crate and adds
349 /// all the functions to the `functions` section.
350 fn parse_function_section(
351 &mut self,
352 functions: &mut crate::FunctionSection,
353 section: wasmparser::FunctionSectionReader<'_>,
354 ) -> Result<(), Error<Self::Error>> {
355 utils::parse_function_section(self, functions, section)
356 }
357
358 /// Parses the input `section` given from the `wasmparser` crate and adds
359 /// all the globals to the `globals` section.
360 fn parse_global_section(
361 &mut self,
362 globals: &mut crate::GlobalSection,
363 section: wasmparser::GlobalSectionReader<'_>,
364 ) -> Result<(), Error<Self::Error>> {
365 utils::parse_global_section(self, globals, section)
366 }
367
368 /// Parses the single [`wasmparser::Global`] provided and adds it to the
369 /// `globals` section.
370 fn parse_global(
371 &mut self,
372 globals: &mut crate::GlobalSection,
373 global: wasmparser::Global<'_>,
374 ) -> Result<(), Error<Self::Error>> {
375 utils::parse_global(self, globals, global)
376 }
377
378 /// Parses the input `section` given from the `wasmparser` crate and adds
379 /// all the imports to the `import` section.
380 fn parse_import_section(
381 &mut self,
382 imports: &mut crate::ImportSection,
383 section: wasmparser::ImportSectionReader<'_>,
384 ) -> Result<(), Error<Self::Error>> {
385 utils::parse_import_section(self, imports, section)
386 }
387
388 /// Parses the single [`wasmparser::Import`] provided and adds it to the
389 /// `import` section.
390 fn parse_import(
391 &mut self,
392 imports: &mut crate::ImportSection,
393 import: wasmparser::Import<'_>,
394 ) -> Result<(), Error<Self::Error>> {
395 utils::parse_import(self, imports, import)
396 }
397
398 /// Parses the input `section` given from the `wasmparser` crate and adds
399 /// all the memories to the `memories` section.
400 fn parse_memory_section(
401 &mut self,
402 memories: &mut crate::MemorySection,
403 section: wasmparser::MemorySectionReader<'_>,
404 ) -> Result<(), Error<Self::Error>> {
405 utils::parse_memory_section(self, memories, section)
406 }
407
408 /// Parses the input `section` given from the `wasmparser` crate and adds
409 /// all the tables to the `tables` section.
410 fn parse_table_section(
411 &mut self,
412 tables: &mut crate::TableSection,
413 section: wasmparser::TableSectionReader<'_>,
414 ) -> Result<(), Error<Self::Error>> {
415 utils::parse_table_section(self, tables, section)
416 }
417
418 /// Parses a single [`wasmparser::Table`] and adds it to the `tables` section.
419 fn parse_table(
420 &mut self,
421 tables: &mut crate::TableSection,
422 table: wasmparser::Table<'_>,
423 ) -> Result<(), Error<Self::Error>> {
424 utils::parse_table(self, tables, table)
425 }
426
427 /// Parses the input `section` given from the `wasmparser` crate and adds
428 /// all the tags to the `tags` section.
429 fn parse_tag_section(
430 &mut self,
431 tags: &mut crate::TagSection,
432 section: wasmparser::TagSectionReader<'_>,
433 ) -> Result<(), Error<Self::Error>> {
434 utils::parse_tag_section(self, tags, section)
435 }
436
437 /// Parses the input `section` given from the `wasmparser` crate and adds
438 /// all the types to the `types` section.
439 fn parse_type_section(
440 &mut self,
441 types: &mut crate::TypeSection,
442 section: wasmparser::TypeSectionReader<'_>,
443 ) -> Result<(), Error<Self::Error>> {
444 utils::parse_type_section(self, types, section)
445 }
446
447 /// Parses a single [`wasmparser::RecGroup`] and adds it to the `types` section.
448 fn parse_recursive_type_group(
449 &mut self,
450 encoder: CoreTypeEncoder,
451 rec_group: wasmparser::RecGroup,
452 ) -> Result<(), Error<Self::Error>> {
453 utils::parse_recursive_type_group(self, encoder, rec_group)
454 }
455
456 fn parse_unknown_section(
457 &mut self,
458 module: &mut crate::Module,
459 id: u8,
460 contents: &[u8],
461 ) -> Result<(), Error<Self::Error>> {
462 utils::parse_unknown_section(self, module, id, contents)
463 }
464
465 /// A hook method that is called inside [`Reencode::parse_core_module`]
466 /// before and after every non-custom core wasm section.
467 ///
468 /// This method can be used to insert new custom sections in between those
469 /// sections, or to detect when a non-custom section is missing and insert
470 /// it in the [proper order].
471 ///
472 /// The `after` parameter is `None` iff the hook is called before the first
473 /// non-custom section, and `Some(s)` afterwards, where `s` is the
474 /// [`SectionId`] of the previous non-custom section.
475 ///
476 /// The `before` parameter is `None` iff the hook is called after the last
477 /// non-custom section, and `Some(s)` beforehand, where `s` is the
478 /// [`SectionId`] of the following non-custom section.
479 ///
480 /// [proper order]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
481 /// [`SectionId`]: crate::SectionId
482 fn intersperse_section_hook(
483 &mut self,
484 module: &mut crate::Module,
485 after: Option<crate::SectionId>,
486 before: Option<crate::SectionId>,
487 ) -> Result<(), Error<Self::Error>> {
488 utils::intersperse_section_hook(self, module, after, before)
489 }
490
491 fn parse_core_module(
492 &mut self,
493 module: &mut crate::Module,
494 parser: wasmparser::Parser,
495 data: &[u8],
496 ) -> Result<(), Error<Self::Error>> {
497 utils::parse_core_module(self, module, parser, data)
498 }
499
500 fn custom_name_section(
501 &mut self,
502 section: wasmparser::NameSectionReader<'_>,
503 ) -> Result<crate::NameSection, Error<Self::Error>> {
504 utils::custom_name_section(self, section)
505 }
506
507 fn parse_custom_name_subsection(
508 &mut self,
509 names: &mut crate::NameSection,
510 section: wasmparser::Name<'_>,
511 ) -> Result<(), Error<Self::Error>> {
512 utils::parse_custom_name_subsection(self, names, section)
513 }
514
515 fn data_count(&mut self, count: u32) -> u32 {
516 count
517 }
518
519 fn start_section(&mut self, start: u32) -> u32 {
520 self.function_index(start)
521 }
522}
523
524/// An error when re-encoding from `wasmparser` to `wasm-encoder`.
525#[derive(Debug)]
526pub enum Error<E = Infallible> {
527 /// There was a type reference that was canonicalized and no longer
528 /// references an index into a module's types space, so we cannot encode it
529 /// into a Wasm binary again.
530 CanonicalizedHeapTypeReference,
531 /// The const expression is invalid: not actually constant or something like
532 /// that.
533 InvalidConstExpr,
534 /// The code section size listed was not valid for the wasm binary provided.
535 InvalidCodeSectionSize,
536 /// There was a section that does not belong into a core wasm module.
537 UnexpectedNonCoreModuleSection,
538 /// There was a section that does not belong into a compoennt module.
539 UnexpectedNonComponentSection,
540 /// A core type definition was found in a component that's not supported.
541 UnsupportedCoreTypeInComponent,
542 /// There was an error when parsing.
543 ParseError(wasmparser::BinaryReaderError),
544 /// There was a user-defined error when re-encoding.
545 UserError(E),
546}
547
548impl<E> From<wasmparser::BinaryReaderError> for Error<E> {
549 fn from(err: wasmparser::BinaryReaderError) -> Self {
550 Self::ParseError(err)
551 }
552}
553
554impl<E: core::fmt::Display> core::fmt::Display for Error<E> {
555 fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
556 match self {
557 Self::ParseError(_e) => {
558 write!(fmt, "There was an error when parsing")
559 }
560 Self::UserError(e) => write!(fmt, "{e}"),
561 Self::InvalidConstExpr => write!(fmt, "The const expression was invalid"),
562 Self::UnexpectedNonCoreModuleSection => write!(
563 fmt,
564 "There was a section that does not belong into a core wasm module"
565 ),
566 Self::UnexpectedNonComponentSection => write!(
567 fmt,
568 "There was a section that does not belong into a component"
569 ),
570 Self::CanonicalizedHeapTypeReference => write!(
571 fmt,
572 "There was a canonicalized heap type reference without type index information"
573 ),
574 Self::UnsupportedCoreTypeInComponent => {
575 fmt.write_str("unsupported core type in a component")
576 }
577 Self::InvalidCodeSectionSize => fmt.write_str("invalid code section size"),
578 }
579 }
580}
581
582#[cfg(any(feature = "std", core_error))]
583impl<E: 'static + StdError> StdError for Error<E> {
584 fn source(&self) -> Option<&(dyn StdError + 'static)> {
585 match self {
586 Self::ParseError(e: &BinaryReaderError) => Some(e),
587 Self::UserError(e: &E) => Some(e),
588 Self::InvalidConstExpr
589 | Self::CanonicalizedHeapTypeReference
590 | Self::UnexpectedNonCoreModuleSection
591 | Self::UnexpectedNonComponentSection
592 | Self::UnsupportedCoreTypeInComponent
593 | Self::InvalidCodeSectionSize => None,
594 }
595 }
596}
597
598/// Reencodes `wasmparser` into `wasm-encoder` so that the encoded wasm is
599/// identical to the input and can be parsed and encoded again.
600#[derive(Debug)]
601pub struct RoundtripReencoder;
602
603impl Reencode for RoundtripReencoder {
604 type Error = Infallible;
605}
606
607#[allow(missing_docs)] // FIXME
608pub mod utils {
609 use super::{Error, Reencode};
610 use crate::{CoreTypeEncoder, Encode};
611 use alloc::vec::Vec;
612 use core::ops::Range;
613
614 pub fn parse_core_module<T: ?Sized + Reencode>(
615 reencoder: &mut T,
616 module: &mut crate::Module,
617 parser: wasmparser::Parser,
618 data: &[u8],
619 ) -> Result<(), Error<T::Error>> {
620 fn handle_intersperse_section_hook<T: ?Sized + Reencode>(
621 reencoder: &mut T,
622 module: &mut crate::Module,
623 last_section: &mut Option<crate::SectionId>,
624 next_section: Option<crate::SectionId>,
625 ) -> Result<(), Error<T::Error>> {
626 let after = core::mem::replace(last_section, next_section);
627 let before = next_section;
628 reencoder.intersperse_section_hook(module, after, before)
629 }
630
631 // Convert from `range` to a byte range within `data` while
632 // accounting for various offsets. Then create a
633 // `CodeSectionReader` (which notably the payload does not
634 // give us here) and recurse with that. This means that
635 // users overridding `parse_code_section` always get that
636 // function called.
637 let orig_offset = parser.offset() as usize;
638 let get_original_section = |range: Range<usize>| {
639 data.get(range.start - orig_offset..range.end - orig_offset)
640 .ok_or(Error::InvalidCodeSectionSize)
641 };
642 let mut last_section = None;
643
644 for section in parser.parse_all(data) {
645 match section? {
646 wasmparser::Payload::Version {
647 encoding: wasmparser::Encoding::Module,
648 ..
649 } => (),
650 wasmparser::Payload::Version { .. } => {
651 return Err(Error::UnexpectedNonCoreModuleSection)
652 }
653 wasmparser::Payload::TypeSection(section) => {
654 handle_intersperse_section_hook(
655 reencoder,
656 module,
657 &mut last_section,
658 Some(crate::SectionId::Type),
659 )?;
660 let mut types = crate::TypeSection::new();
661 reencoder.parse_type_section(&mut types, section)?;
662 module.section(&types);
663 }
664 wasmparser::Payload::ImportSection(section) => {
665 handle_intersperse_section_hook(
666 reencoder,
667 module,
668 &mut last_section,
669 Some(crate::SectionId::Import),
670 )?;
671 let mut imports = crate::ImportSection::new();
672 reencoder.parse_import_section(&mut imports, section)?;
673 module.section(&imports);
674 }
675 wasmparser::Payload::FunctionSection(section) => {
676 handle_intersperse_section_hook(
677 reencoder,
678 module,
679 &mut last_section,
680 Some(crate::SectionId::Function),
681 )?;
682 let mut functions = crate::FunctionSection::new();
683 reencoder.parse_function_section(&mut functions, section)?;
684 module.section(&functions);
685 }
686 wasmparser::Payload::TableSection(section) => {
687 handle_intersperse_section_hook(
688 reencoder,
689 module,
690 &mut last_section,
691 Some(crate::SectionId::Table),
692 )?;
693 let mut tables = crate::TableSection::new();
694 reencoder.parse_table_section(&mut tables, section)?;
695 module.section(&tables);
696 }
697 wasmparser::Payload::MemorySection(section) => {
698 handle_intersperse_section_hook(
699 reencoder,
700 module,
701 &mut last_section,
702 Some(crate::SectionId::Memory),
703 )?;
704 let mut memories = crate::MemorySection::new();
705 reencoder.parse_memory_section(&mut memories, section)?;
706 module.section(&memories);
707 }
708 wasmparser::Payload::TagSection(section) => {
709 handle_intersperse_section_hook(
710 reencoder,
711 module,
712 &mut last_section,
713 Some(crate::SectionId::Tag),
714 )?;
715 let mut tags = crate::TagSection::new();
716 reencoder.parse_tag_section(&mut tags, section)?;
717 module.section(&tags);
718 }
719 wasmparser::Payload::GlobalSection(section) => {
720 handle_intersperse_section_hook(
721 reencoder,
722 module,
723 &mut last_section,
724 Some(crate::SectionId::Global),
725 )?;
726 let mut globals = crate::GlobalSection::new();
727 reencoder.parse_global_section(&mut globals, section)?;
728 module.section(&globals);
729 }
730 wasmparser::Payload::ExportSection(section) => {
731 handle_intersperse_section_hook(
732 reencoder,
733 module,
734 &mut last_section,
735 Some(crate::SectionId::Export),
736 )?;
737 let mut exports = crate::ExportSection::new();
738 reencoder.parse_export_section(&mut exports, section)?;
739 module.section(&exports);
740 }
741 wasmparser::Payload::StartSection { func, .. } => {
742 handle_intersperse_section_hook(
743 reencoder,
744 module,
745 &mut last_section,
746 Some(crate::SectionId::Start),
747 )?;
748 module.section(&crate::StartSection {
749 function_index: reencoder.start_section(func),
750 });
751 }
752 wasmparser::Payload::ElementSection(section) => {
753 handle_intersperse_section_hook(
754 reencoder,
755 module,
756 &mut last_section,
757 Some(crate::SectionId::Element),
758 )?;
759 let mut elements = crate::ElementSection::new();
760 reencoder.parse_element_section(&mut elements, section)?;
761 module.section(&elements);
762 }
763 wasmparser::Payload::DataCountSection { count, .. } => {
764 handle_intersperse_section_hook(
765 reencoder,
766 module,
767 &mut last_section,
768 Some(crate::SectionId::DataCount),
769 )?;
770 let count = reencoder.data_count(count);
771 module.section(&crate::DataCountSection { count });
772 }
773 wasmparser::Payload::DataSection(section) => {
774 handle_intersperse_section_hook(
775 reencoder,
776 module,
777 &mut last_section,
778 Some(crate::SectionId::Data),
779 )?;
780 let mut data = crate::DataSection::new();
781 reencoder.parse_data_section(&mut data, section)?;
782 module.section(&data);
783 }
784 wasmparser::Payload::CodeSectionStart { range, .. } => {
785 handle_intersperse_section_hook(
786 reencoder,
787 module,
788 &mut last_section,
789 Some(crate::SectionId::Code),
790 )?;
791 let mut codes = crate::CodeSection::new();
792
793 // Convert from `range` to a byte range within `data` while
794 // accounting for various offsets. Then create a
795 // `CodeSectionReader` (which notably the payload does not
796 // give us here) and recurse with that. This means that
797 // users overridding `parse_code_section` always get that
798 // function called.
799 let section = get_original_section(range.clone())?;
800 let reader = wasmparser::BinaryReader::new(section, range.start);
801 let section = wasmparser::CodeSectionReader::new(reader)?;
802 reencoder.parse_code_section(&mut codes, section)?;
803 module.section(&codes);
804 }
805
806 // Parsing of code section entries (function bodies) happens
807 // above during the handling of the code section. That means
808 // that we just skip all these payloads.
809 wasmparser::Payload::CodeSectionEntry(_) => {}
810
811 #[cfg(feature = "component-model")]
812 wasmparser::Payload::ModuleSection { .. }
813 | wasmparser::Payload::InstanceSection(_)
814 | wasmparser::Payload::CoreTypeSection(_)
815 | wasmparser::Payload::ComponentSection { .. }
816 | wasmparser::Payload::ComponentInstanceSection(_)
817 | wasmparser::Payload::ComponentAliasSection(_)
818 | wasmparser::Payload::ComponentTypeSection(_)
819 | wasmparser::Payload::ComponentCanonicalSection(_)
820 | wasmparser::Payload::ComponentStartSection { .. }
821 | wasmparser::Payload::ComponentImportSection(_)
822 | wasmparser::Payload::ComponentExportSection(_) => {
823 return Err(Error::UnexpectedNonCoreModuleSection)
824 }
825 wasmparser::Payload::CustomSection(section) => {
826 reencoder.parse_custom_section(module, section)?;
827 }
828 wasmparser::Payload::End(_) => {
829 handle_intersperse_section_hook(reencoder, module, &mut last_section, None)?;
830 }
831
832 other => match other.as_section() {
833 Some((id, range)) => {
834 let section = get_original_section(range)?;
835 reencoder.parse_unknown_section(module, id, section)?;
836 }
837 None => unreachable!(),
838 },
839 }
840 }
841
842 Ok(())
843 }
844
845 /// A hook method that is called inside [`Reencode::parse_core_module`]
846 /// before and after every non-custom core wasm section.
847 ///
848 /// This method can be used to insert new custom sections in between those
849 /// sections, or to detect when a non-custom section is missing and insert
850 /// it in the [proper order].
851 ///
852 /// The `after` parameter is `None` iff the hook is called before the first
853 /// non-custom section, and `Some(s)` afterwards, where `s` is the
854 /// [`SectionId`] of the previous non-custom section.
855 ///
856 /// The `before` parameter is `None` iff the hook is called after the last
857 /// non-custom section, and `Some(s)` beforehand, where `s` is the
858 /// [`SectionId`] of the following non-custom section.
859 ///
860 /// [proper order]: https://webassembly.github.io/spec/core/binary/modules.html#binary-module
861 /// [`SectionId`]: crate::SectionId
862 pub fn intersperse_section_hook<T: ?Sized + Reencode>(
863 _reencoder: &mut T,
864 _module: &mut crate::Module,
865 _after: Option<crate::SectionId>,
866 _before: Option<crate::SectionId>,
867 ) -> Result<(), Error<T::Error>> {
868 Ok(())
869 }
870
871 pub fn memory_index<T: ?Sized + Reencode>(_reencoder: &mut T, memory: u32) -> u32 {
872 memory
873 }
874
875 pub fn mem_arg<T: ?Sized + Reencode>(
876 reencoder: &mut T,
877 arg: wasmparser::MemArg,
878 ) -> crate::MemArg {
879 crate::MemArg {
880 offset: arg.offset,
881 align: arg.align.into(),
882 memory_index: reencoder.memory_index(arg.memory),
883 }
884 }
885
886 pub fn ordering<T: ?Sized + Reencode>(
887 _reencoder: &mut T,
888 arg: wasmparser::Ordering,
889 ) -> crate::Ordering {
890 match arg {
891 wasmparser::Ordering::SeqCst => crate::Ordering::SeqCst,
892 wasmparser::Ordering::AcqRel => crate::Ordering::AcqRel,
893 }
894 }
895
896 pub fn function_index<T: ?Sized + Reencode>(_reencoder: &mut T, func: u32) -> u32 {
897 func
898 }
899
900 pub fn tag_index<T: ?Sized + Reencode>(_reencoder: &mut T, tag: u32) -> u32 {
901 tag
902 }
903
904 pub fn catch<T: ?Sized + Reencode>(reencoder: &mut T, arg: wasmparser::Catch) -> crate::Catch {
905 match arg {
906 wasmparser::Catch::One { tag, label } => crate::Catch::One {
907 tag: reencoder.tag_index(tag),
908 label,
909 },
910 wasmparser::Catch::OneRef { tag, label } => crate::Catch::OneRef {
911 tag: reencoder.tag_index(tag),
912 label,
913 },
914 wasmparser::Catch::All { label } => crate::Catch::All { label },
915 wasmparser::Catch::AllRef { label } => crate::Catch::AllRef { label },
916 }
917 }
918
919 pub fn handle<T: ?Sized + Reencode>(
920 reencoder: &mut T,
921 arg: wasmparser::Handle,
922 ) -> crate::Handle {
923 match arg {
924 wasmparser::Handle::OnLabel { tag, label } => crate::Handle::OnLabel {
925 tag: reencoder.tag_index(tag),
926 label,
927 },
928 wasmparser::Handle::OnSwitch { tag } => crate::Handle::OnSwitch {
929 tag: reencoder.tag_index(tag),
930 },
931 }
932 }
933
934 /// Parses the input `section` given from the `wasmparser` crate and
935 /// adds the custom section to the `module`.
936 pub fn parse_custom_section<T: ?Sized + Reencode>(
937 reencoder: &mut T,
938 module: &mut crate::Module,
939 section: wasmparser::CustomSectionReader<'_>,
940 ) -> Result<(), Error<T::Error>> {
941 match section.as_known() {
942 wasmparser::KnownCustom::Name(name) => {
943 module.section(&reencoder.custom_name_section(name)?);
944 }
945 _ => {
946 module.section(&reencoder.custom_section(section));
947 }
948 }
949 Ok(())
950 }
951
952 /// Converts the input `section` given from the `wasmparser` crate into an
953 /// encoded custom section.
954 pub fn custom_section<'a, T: ?Sized + Reencode>(
955 _reencoder: &mut T,
956 section: wasmparser::CustomSectionReader<'a>,
957 ) -> crate::CustomSection<'a> {
958 crate::CustomSection {
959 data: section.data().into(),
960 name: section.name().into(),
961 }
962 }
963
964 pub fn export_kind<T: ?Sized + Reencode>(
965 _reencoder: &mut T,
966 external_kind: wasmparser::ExternalKind,
967 ) -> crate::ExportKind {
968 match external_kind {
969 wasmparser::ExternalKind::Func => crate::ExportKind::Func,
970 wasmparser::ExternalKind::Table => crate::ExportKind::Table,
971 wasmparser::ExternalKind::Memory => crate::ExportKind::Memory,
972 wasmparser::ExternalKind::Global => crate::ExportKind::Global,
973 wasmparser::ExternalKind::Tag => crate::ExportKind::Tag,
974 }
975 }
976
977 pub fn memory_type<T: ?Sized + Reencode>(
978 _reencoder: &mut T,
979 memory_ty: wasmparser::MemoryType,
980 ) -> crate::MemoryType {
981 crate::MemoryType {
982 minimum: memory_ty.initial,
983 maximum: memory_ty.maximum,
984 memory64: memory_ty.memory64,
985 shared: memory_ty.shared,
986 page_size_log2: memory_ty.page_size_log2,
987 }
988 }
989
990 pub fn tag_kind<T: ?Sized + Reencode>(
991 _reencoder: &mut T,
992 kind: wasmparser::TagKind,
993 ) -> crate::TagKind {
994 match kind {
995 wasmparser::TagKind::Exception => crate::TagKind::Exception,
996 }
997 }
998
999 pub fn type_index<T: ?Sized + Reencode>(_reencoder: &mut T, ty: u32) -> u32 {
1000 ty
1001 }
1002
1003 pub fn type_index_unpacked<T: ?Sized + Reencode>(
1004 reencoder: &mut T,
1005 ty: wasmparser::UnpackedIndex,
1006 ) -> Result<u32, Error<T::Error>> {
1007 ty.as_module_index()
1008 .map(|ty| reencoder.type_index(ty))
1009 .ok_or(Error::CanonicalizedHeapTypeReference)
1010 }
1011
1012 pub fn tag_type<T: ?Sized + Reencode>(
1013 reencoder: &mut T,
1014 tag_ty: wasmparser::TagType,
1015 ) -> crate::TagType {
1016 crate::TagType {
1017 kind: reencoder.tag_kind(tag_ty.kind),
1018 func_type_idx: reencoder.type_index(tag_ty.func_type_idx),
1019 }
1020 }
1021
1022 pub fn abstract_heap_type<T: ?Sized + Reencode>(
1023 _reencoder: &mut T,
1024 value: wasmparser::AbstractHeapType,
1025 ) -> crate::AbstractHeapType {
1026 use wasmparser::AbstractHeapType::*;
1027 match value {
1028 Func => crate::AbstractHeapType::Func,
1029 Extern => crate::AbstractHeapType::Extern,
1030 Any => crate::AbstractHeapType::Any,
1031 None => crate::AbstractHeapType::None,
1032 NoExtern => crate::AbstractHeapType::NoExtern,
1033 NoFunc => crate::AbstractHeapType::NoFunc,
1034 Eq => crate::AbstractHeapType::Eq,
1035 Struct => crate::AbstractHeapType::Struct,
1036 Array => crate::AbstractHeapType::Array,
1037 I31 => crate::AbstractHeapType::I31,
1038 Exn => crate::AbstractHeapType::Exn,
1039 NoExn => crate::AbstractHeapType::NoExn,
1040 Cont => crate::AbstractHeapType::Cont,
1041 NoCont => crate::AbstractHeapType::NoCont,
1042 }
1043 }
1044
1045 /// Parses the input `section` given from the `wasmparser` crate and adds
1046 /// all the types to the `types` section.
1047 pub fn parse_type_section<T: ?Sized + Reencode>(
1048 reencoder: &mut T,
1049 types: &mut crate::TypeSection,
1050 section: wasmparser::TypeSectionReader<'_>,
1051 ) -> Result<(), Error<T::Error>> {
1052 for rec_group in section {
1053 reencoder.parse_recursive_type_group(types.ty(), rec_group?)?;
1054 }
1055 Ok(())
1056 }
1057
1058 /// Parses a single [`wasmparser::RecGroup`] and adds it to the `types` section.
1059 pub fn parse_recursive_type_group<T: ?Sized + Reencode>(
1060 reencoder: &mut T,
1061 encoder: CoreTypeEncoder,
1062 rec_group: wasmparser::RecGroup,
1063 ) -> Result<(), Error<T::Error>> {
1064 if rec_group.is_explicit_rec_group() {
1065 let subtypes = rec_group
1066 .into_types()
1067 .map(|t| reencoder.sub_type(t))
1068 .collect::<Result<Vec<_>, _>>()?;
1069 encoder.rec(subtypes);
1070 } else {
1071 let ty = rec_group.into_types().next().unwrap();
1072 encoder.subtype(&reencoder.sub_type(ty)?);
1073 }
1074 Ok(())
1075 }
1076
1077 pub fn sub_type<T: ?Sized + Reencode>(
1078 reencoder: &mut T,
1079 sub_ty: wasmparser::SubType,
1080 ) -> Result<crate::SubType, Error<T::Error>> {
1081 Ok(crate::SubType {
1082 is_final: sub_ty.is_final,
1083 supertype_idx: sub_ty
1084 .supertype_idx
1085 .map(|i| reencoder.type_index_unpacked(i.unpack()))
1086 .transpose()?,
1087 composite_type: reencoder.composite_type(sub_ty.composite_type)?,
1088 })
1089 }
1090
1091 pub fn composite_type<T: ?Sized + Reencode>(
1092 reencoder: &mut T,
1093 composite_ty: wasmparser::CompositeType,
1094 ) -> Result<crate::CompositeType, Error<T::Error>> {
1095 let inner = match composite_ty.inner {
1096 wasmparser::CompositeInnerType::Func(f) => {
1097 crate::CompositeInnerType::Func(reencoder.func_type(f)?)
1098 }
1099 wasmparser::CompositeInnerType::Array(a) => {
1100 crate::CompositeInnerType::Array(reencoder.array_type(a)?)
1101 }
1102 wasmparser::CompositeInnerType::Struct(s) => {
1103 crate::CompositeInnerType::Struct(reencoder.struct_type(s)?)
1104 }
1105 wasmparser::CompositeInnerType::Cont(c) => {
1106 crate::CompositeInnerType::Cont(reencoder.cont_type(c)?)
1107 }
1108 };
1109 Ok(crate::CompositeType {
1110 inner,
1111 shared: composite_ty.shared,
1112 })
1113 }
1114
1115 pub fn func_type<T: ?Sized + Reencode>(
1116 reencoder: &mut T,
1117 func_ty: wasmparser::FuncType,
1118 ) -> Result<crate::FuncType, Error<T::Error>> {
1119 let mut buf = Vec::with_capacity(func_ty.params().len() + func_ty.results().len());
1120 for ty in func_ty.params().iter().chain(func_ty.results()).copied() {
1121 buf.push(reencoder.val_type(ty)?);
1122 }
1123 Ok(crate::FuncType::from_parts(
1124 buf.into(),
1125 func_ty.params().len(),
1126 ))
1127 }
1128
1129 pub fn array_type<T: ?Sized + Reencode>(
1130 reencoder: &mut T,
1131 array_ty: wasmparser::ArrayType,
1132 ) -> Result<crate::ArrayType, Error<T::Error>> {
1133 Ok(crate::ArrayType(reencoder.field_type(array_ty.0)?))
1134 }
1135
1136 pub fn struct_type<T: ?Sized + Reencode>(
1137 reencoder: &mut T,
1138 struct_ty: wasmparser::StructType,
1139 ) -> Result<crate::StructType, Error<T::Error>> {
1140 Ok(crate::StructType {
1141 fields: struct_ty
1142 .fields
1143 .iter()
1144 .map(|field_ty| reencoder.field_type(*field_ty))
1145 .collect::<Result<_, _>>()?,
1146 })
1147 }
1148
1149 pub fn field_type<T: ?Sized + Reencode>(
1150 reencoder: &mut T,
1151 field_ty: wasmparser::FieldType,
1152 ) -> Result<crate::FieldType, Error<T::Error>> {
1153 Ok(crate::FieldType {
1154 element_type: reencoder.storage_type(field_ty.element_type)?,
1155 mutable: field_ty.mutable,
1156 })
1157 }
1158
1159 pub fn storage_type<T: ?Sized + Reencode>(
1160 reencoder: &mut T,
1161 storage_ty: wasmparser::StorageType,
1162 ) -> Result<crate::StorageType, Error<T::Error>> {
1163 Ok(match storage_ty {
1164 wasmparser::StorageType::I8 => crate::StorageType::I8,
1165 wasmparser::StorageType::I16 => crate::StorageType::I16,
1166 wasmparser::StorageType::Val(v) => crate::StorageType::Val(reencoder.val_type(v)?),
1167 })
1168 }
1169
1170 pub fn cont_type<T: ?Sized + Reencode>(
1171 reencoder: &mut T,
1172 cont_ty: wasmparser::ContType,
1173 ) -> Result<crate::ContType, Error<T::Error>> {
1174 Ok(crate::ContType(
1175 reencoder.type_index_unpacked(cont_ty.0.unpack())?,
1176 ))
1177 }
1178
1179 pub fn val_type<T: ?Sized + Reencode>(
1180 reencoder: &mut T,
1181 val_ty: wasmparser::ValType,
1182 ) -> Result<crate::ValType, Error<T::Error>> {
1183 Ok(match val_ty {
1184 wasmparser::ValType::I32 => crate::ValType::I32,
1185 wasmparser::ValType::I64 => crate::ValType::I64,
1186 wasmparser::ValType::F32 => crate::ValType::F32,
1187 wasmparser::ValType::F64 => crate::ValType::F64,
1188 wasmparser::ValType::V128 => crate::ValType::V128,
1189 wasmparser::ValType::Ref(r) => crate::ValType::Ref(reencoder.ref_type(r)?),
1190 })
1191 }
1192
1193 pub fn ref_type<T: ?Sized + Reencode>(
1194 reencoder: &mut T,
1195 ref_type: wasmparser::RefType,
1196 ) -> Result<crate::RefType, Error<T::Error>> {
1197 Ok(crate::RefType {
1198 nullable: ref_type.is_nullable(),
1199 heap_type: reencoder.heap_type(ref_type.heap_type())?,
1200 })
1201 }
1202
1203 pub fn heap_type<T: ?Sized + Reencode>(
1204 reencoder: &mut T,
1205 heap_type: wasmparser::HeapType,
1206 ) -> Result<crate::HeapType, Error<T::Error>> {
1207 Ok(match heap_type {
1208 wasmparser::HeapType::Concrete(i) => {
1209 crate::HeapType::Concrete(reencoder.type_index_unpacked(i)?)
1210 }
1211 wasmparser::HeapType::Abstract { shared, ty } => crate::HeapType::Abstract {
1212 shared,
1213 ty: reencoder.abstract_heap_type(ty),
1214 },
1215 })
1216 }
1217
1218 /// Parses the input `section` given from the `wasmparser` crate and adds
1219 /// all the tables to the `tables` section.
1220 pub fn parse_table_section<T: ?Sized + Reencode>(
1221 reencoder: &mut T,
1222 tables: &mut crate::TableSection,
1223 section: wasmparser::TableSectionReader<'_>,
1224 ) -> Result<(), Error<T::Error>> {
1225 for table in section {
1226 reencoder.parse_table(tables, table?)?;
1227 }
1228 Ok(())
1229 }
1230
1231 /// Parses a single [`wasmparser::Table`] and adds it to the `tables` section.
1232 pub fn parse_table<T: ?Sized + Reencode>(
1233 reencoder: &mut T,
1234 tables: &mut crate::TableSection,
1235 table: wasmparser::Table<'_>,
1236 ) -> Result<(), Error<T::Error>> {
1237 let ty = reencoder.table_type(table.ty)?;
1238 match table.init {
1239 wasmparser::TableInit::RefNull => {
1240 tables.table(ty);
1241 }
1242 wasmparser::TableInit::Expr(e) => {
1243 tables.table_with_init(ty, &reencoder.const_expr(e)?);
1244 }
1245 }
1246 Ok(())
1247 }
1248
1249 pub fn table_type<T: ?Sized + Reencode>(
1250 reencoder: &mut T,
1251 table_ty: wasmparser::TableType,
1252 ) -> Result<crate::TableType, Error<T::Error>> {
1253 Ok(crate::TableType {
1254 element_type: reencoder.ref_type(table_ty.element_type)?,
1255 minimum: table_ty.initial,
1256 maximum: table_ty.maximum,
1257 table64: table_ty.table64,
1258 shared: table_ty.shared,
1259 })
1260 }
1261
1262 /// Parses the input `section` given from the `wasmparser` crate and adds
1263 /// all the tags to the `tags` section.
1264 pub fn parse_tag_section<T: ?Sized + Reencode>(
1265 reencoder: &mut T,
1266 tags: &mut crate::TagSection,
1267 section: wasmparser::TagSectionReader<'_>,
1268 ) -> Result<(), Error<T::Error>> {
1269 for tag in section {
1270 let tag = tag?;
1271 tags.tag(reencoder.tag_type(tag));
1272 }
1273 Ok(())
1274 }
1275
1276 /// Parses the input `section` given from the `wasmparser` crate and adds
1277 /// all the exports to the `exports` section.
1278 pub fn parse_export_section<T: ?Sized + Reencode>(
1279 reencoder: &mut T,
1280 exports: &mut crate::ExportSection,
1281 section: wasmparser::ExportSectionReader<'_>,
1282 ) -> Result<(), Error<T::Error>> {
1283 for export in section {
1284 reencoder.parse_export(exports, export?);
1285 }
1286 Ok(())
1287 }
1288
1289 /// Parses the single [`wasmparser::Export`] provided and adds it to the
1290 /// `exports` section.
1291 pub fn parse_export<T: ?Sized + Reencode>(
1292 reencoder: &mut T,
1293 exports: &mut crate::ExportSection,
1294 export: wasmparser::Export<'_>,
1295 ) {
1296 exports.export(
1297 export.name,
1298 reencoder.export_kind(export.kind),
1299 reencoder.external_index(export.kind, export.index),
1300 );
1301 }
1302
1303 /// Parses the input `section` given from the `wasmparser` crate and adds
1304 /// all the globals to the `globals` section.
1305 pub fn parse_global_section<T: ?Sized + Reencode>(
1306 reencoder: &mut T,
1307 globals: &mut crate::GlobalSection,
1308 section: wasmparser::GlobalSectionReader<'_>,
1309 ) -> Result<(), Error<T::Error>> {
1310 for global in section {
1311 reencoder.parse_global(globals, global?)?;
1312 }
1313 Ok(())
1314 }
1315
1316 /// Parses the single [`wasmparser::Global`] provided and adds it to the
1317 /// `globals` section.
1318 pub fn parse_global<T: ?Sized + Reencode>(
1319 reencoder: &mut T,
1320 globals: &mut crate::GlobalSection,
1321 global: wasmparser::Global<'_>,
1322 ) -> Result<(), Error<T::Error>> {
1323 globals.global(
1324 reencoder.global_type(global.ty)?,
1325 &reencoder.const_expr(global.init_expr)?,
1326 );
1327 Ok(())
1328 }
1329
1330 pub fn global_type<T: ?Sized + Reencode>(
1331 reencoder: &mut T,
1332 global_ty: wasmparser::GlobalType,
1333 ) -> Result<crate::GlobalType, Error<T::Error>> {
1334 Ok(crate::GlobalType {
1335 val_type: reencoder.val_type(global_ty.content_type)?,
1336 mutable: global_ty.mutable,
1337 shared: global_ty.shared,
1338 })
1339 }
1340
1341 pub fn entity_type<T: ?Sized + Reencode>(
1342 reencoder: &mut T,
1343 type_ref: wasmparser::TypeRef,
1344 ) -> Result<crate::EntityType, Error<T::Error>> {
1345 Ok(match type_ref {
1346 wasmparser::TypeRef::Func(i) => crate::EntityType::Function(reencoder.type_index(i)),
1347 wasmparser::TypeRef::Table(t) => crate::EntityType::Table(reencoder.table_type(t)?),
1348 wasmparser::TypeRef::Memory(m) => crate::EntityType::Memory(reencoder.memory_type(m)),
1349 wasmparser::TypeRef::Global(g) => crate::EntityType::Global(reencoder.global_type(g)?),
1350 wasmparser::TypeRef::Tag(t) => crate::EntityType::Tag(reencoder.tag_type(t)),
1351 })
1352 }
1353
1354 /// Parses the input `section` given from the `wasmparser` crate and adds
1355 /// all the imports to the `import` section.
1356 pub fn parse_import_section<T: ?Sized + Reencode>(
1357 reencoder: &mut T,
1358 imports: &mut crate::ImportSection,
1359 section: wasmparser::ImportSectionReader<'_>,
1360 ) -> Result<(), Error<T::Error>> {
1361 for import in section {
1362 reencoder.parse_import(imports, import?)?;
1363 }
1364 Ok(())
1365 }
1366
1367 /// Parses the single [`wasmparser::Import`] provided and adds it to the
1368 /// `import` section.
1369 pub fn parse_import<T: ?Sized + Reencode>(
1370 reencoder: &mut T,
1371 imports: &mut crate::ImportSection,
1372 import: wasmparser::Import<'_>,
1373 ) -> Result<(), Error<T::Error>> {
1374 imports.import(
1375 import.module,
1376 import.name,
1377 reencoder.entity_type(import.ty)?,
1378 );
1379 Ok(())
1380 }
1381
1382 /// Parses the input `section` given from the `wasmparser` crate and adds
1383 /// all the memories to the `memories` section.
1384 pub fn parse_memory_section<T: ?Sized + Reencode>(
1385 reencoder: &mut T,
1386 memories: &mut crate::MemorySection,
1387 section: wasmparser::MemorySectionReader<'_>,
1388 ) -> Result<(), Error<T::Error>> {
1389 for memory in section {
1390 let memory = memory?;
1391 memories.memory(reencoder.memory_type(memory));
1392 }
1393 Ok(())
1394 }
1395
1396 /// Parses the input `section` given from the `wasmparser` crate and adds
1397 /// all the functions to the `functions` section.
1398 pub fn parse_function_section<T: ?Sized + Reencode>(
1399 reencoder: &mut T,
1400 functions: &mut crate::FunctionSection,
1401 section: wasmparser::FunctionSectionReader<'_>,
1402 ) -> Result<(), Error<T::Error>> {
1403 for func in section {
1404 functions.function(reencoder.type_index(func?));
1405 }
1406 Ok(())
1407 }
1408
1409 /// Parses the input `section` given from the `wasmparser` crate and adds
1410 /// all the data to the `data` section.
1411 pub fn parse_data_section<T: ?Sized + Reencode>(
1412 reencoder: &mut T,
1413 data: &mut crate::DataSection,
1414 section: wasmparser::DataSectionReader<'_>,
1415 ) -> Result<(), Error<T::Error>> {
1416 for datum in section {
1417 reencoder.parse_data(data, datum?)?;
1418 }
1419 Ok(())
1420 }
1421
1422 /// Parses a single [`wasmparser::Data`] and adds it to the `data` section.
1423 pub fn parse_data<T: ?Sized + Reencode>(
1424 reencoder: &mut T,
1425 data: &mut crate::DataSection,
1426 datum: wasmparser::Data<'_>,
1427 ) -> Result<(), Error<T::Error>> {
1428 match datum.kind {
1429 wasmparser::DataKind::Active {
1430 memory_index,
1431 offset_expr,
1432 } => data.active(
1433 reencoder.memory_index(memory_index),
1434 &reencoder.const_expr(offset_expr)?,
1435 datum.data.iter().copied(),
1436 ),
1437 wasmparser::DataKind::Passive => data.passive(datum.data.iter().copied()),
1438 };
1439 Ok(())
1440 }
1441
1442 /// Parses the input `section` given from the `wasmparser` crate and adds
1443 /// all the elements to the `element` section.
1444 pub fn parse_element_section<T: ?Sized + Reencode>(
1445 reencoder: &mut T,
1446 elements: &mut crate::ElementSection,
1447 section: wasmparser::ElementSectionReader<'_>,
1448 ) -> Result<(), Error<T::Error>> {
1449 for element in section {
1450 reencoder.parse_element(elements, element?)?;
1451 }
1452 Ok(())
1453 }
1454
1455 /// Parses the single [`wasmparser::Element`] provided and adds it to the
1456 /// `element` section.
1457 pub fn parse_element<T: ?Sized + Reencode>(
1458 reencoder: &mut T,
1459 elements: &mut crate::ElementSection,
1460 element: wasmparser::Element<'_>,
1461 ) -> Result<(), Error<T::Error>> {
1462 let elems = reencoder.element_items(element.items)?;
1463 match element.kind {
1464 wasmparser::ElementKind::Active {
1465 table_index,
1466 offset_expr,
1467 } => elements.active(
1468 // Inform the reencoder that a table index is being used even if
1469 // it's not actually present here. That helps wasm-mutate for
1470 // example which wants to track uses to know when it's ok to
1471 // remove a table.
1472 //
1473 // If the table index started at `None` and is still zero then
1474 // preserve this encoding and keep it at `None`. Otherwise if
1475 // the result is nonzero or it was previously nonzero then keep
1476 // that encoding too.
1477 match (table_index, reencoder.table_index(table_index.unwrap_or(0))) {
1478 (None, 0) => None,
1479 (_, n) => Some(n),
1480 },
1481 &reencoder.const_expr(offset_expr)?,
1482 elems,
1483 ),
1484 wasmparser::ElementKind::Passive => elements.passive(elems),
1485 wasmparser::ElementKind::Declared => elements.declared(elems),
1486 };
1487 Ok(())
1488 }
1489
1490 pub fn element_items<'a, T: ?Sized + Reencode>(
1491 reencoder: &mut T,
1492 items: wasmparser::ElementItems<'a>,
1493 ) -> Result<crate::Elements<'a>, Error<T::Error>> {
1494 Ok(match items {
1495 wasmparser::ElementItems::Functions(f) => {
1496 let mut funcs = Vec::new();
1497 for func in f {
1498 funcs.push(reencoder.function_index(func?));
1499 }
1500 crate::Elements::Functions(funcs.into())
1501 }
1502 wasmparser::ElementItems::Expressions(ty, e) => {
1503 let mut exprs = Vec::new();
1504 for expr in e {
1505 exprs.push(reencoder.const_expr(expr?)?);
1506 }
1507 crate::Elements::Expressions(reencoder.ref_type(ty)?, exprs.into())
1508 }
1509 })
1510 }
1511
1512 pub fn table_index<T: ?Sized + Reencode>(_reencoder: &mut T, table: u32) -> u32 {
1513 table
1514 }
1515
1516 pub fn global_index<T: ?Sized + Reencode>(_reencoder: &mut T, global: u32) -> u32 {
1517 global
1518 }
1519
1520 pub fn data_index<T: ?Sized + Reencode>(_reencoder: &mut T, data: u32) -> u32 {
1521 data
1522 }
1523
1524 pub fn element_index<T: ?Sized + Reencode>(_reencoder: &mut T, element: u32) -> u32 {
1525 element
1526 }
1527
1528 pub fn const_expr<T: ?Sized + Reencode>(
1529 reencoder: &mut T,
1530 const_expr: wasmparser::ConstExpr,
1531 ) -> Result<crate::ConstExpr, Error<T::Error>> {
1532 let mut ops = const_expr.get_operators_reader();
1533 let mut bytes = Vec::new();
1534
1535 while !ops.is_end_then_eof() {
1536 let insn = reencoder.parse_instruction(&mut ops)?;
1537 insn.encode(&mut bytes);
1538 }
1539
1540 Ok(crate::ConstExpr::raw(bytes))
1541 }
1542
1543 pub fn block_type<T: ?Sized + Reencode>(
1544 reencoder: &mut T,
1545 arg: wasmparser::BlockType,
1546 ) -> Result<crate::BlockType, Error<T::Error>> {
1547 match arg {
1548 wasmparser::BlockType::Empty => Ok(crate::BlockType::Empty),
1549 wasmparser::BlockType::FuncType(n) => {
1550 Ok(crate::BlockType::FunctionType(reencoder.type_index(n)))
1551 }
1552 wasmparser::BlockType::Type(t) => Ok(crate::BlockType::Result(reencoder.val_type(t)?)),
1553 }
1554 }
1555
1556 pub fn instruction<'a, T: ?Sized + Reencode>(
1557 reencoder: &mut T,
1558 arg: wasmparser::Operator<'a>,
1559 ) -> Result<crate::Instruction<'a>, Error<T::Error>> {
1560 use crate::Instruction;
1561
1562 macro_rules! translate {
1563 ($( @$proposal:ident $op:ident $({ $($arg:ident: $argty:ty),* })? => $visit:ident ($($ann:tt)*))*) => {
1564 Ok(match arg {
1565 $(
1566 wasmparser::Operator::$op $({ $($arg),* })? => {
1567 $(
1568 $(let $arg = translate!(map $arg $arg);)*
1569 )?
1570 translate!(build $op $($($arg)*)?)
1571 }
1572 )*
1573 unexpected => unreachable!("encountered unexpected Wasm operator: {unexpected:?}"),
1574 })
1575 };
1576
1577 // This case is used to map, based on the name of the field, from the
1578 // wasmparser payload type to the wasm-encoder payload type through
1579 // `Translator` as applicable.
1580 (map $arg:ident tag_index) => (reencoder.tag_index($arg));
1581 (map $arg:ident function_index) => (reencoder.function_index($arg));
1582 (map $arg:ident table) => (reencoder.table_index($arg));
1583 (map $arg:ident table_index) => (reencoder.table_index($arg));
1584 (map $arg:ident dst_table) => (reencoder.table_index($arg));
1585 (map $arg:ident src_table) => (reencoder.table_index($arg));
1586 (map $arg:ident type_index) => (reencoder.type_index($arg));
1587 (map $arg:ident array_type_index) => (reencoder.type_index($arg));
1588 (map $arg:ident array_type_index_dst) => (reencoder.type_index($arg));
1589 (map $arg:ident array_type_index_src) => (reencoder.type_index($arg));
1590 (map $arg:ident struct_type_index) => (reencoder.type_index($arg));
1591 (map $arg:ident global_index) => (reencoder.global_index($arg));
1592 (map $arg:ident mem) => (reencoder.memory_index($arg));
1593 (map $arg:ident src_mem) => (reencoder.memory_index($arg));
1594 (map $arg:ident dst_mem) => (reencoder.memory_index($arg));
1595 (map $arg:ident data_index) => (reencoder.data_index($arg));
1596 (map $arg:ident elem_index) => (reencoder.element_index($arg));
1597 (map $arg:ident array_data_index) => (reencoder.data_index($arg));
1598 (map $arg:ident array_elem_index) => (reencoder.element_index($arg));
1599 (map $arg:ident blockty) => (reencoder.block_type($arg)?);
1600 (map $arg:ident relative_depth) => ($arg);
1601 (map $arg:ident targets) => ((
1602 $arg
1603 .targets()
1604 .collect::<Result<Vec<_>, wasmparser::BinaryReaderError>>()?
1605 .into(),
1606 $arg.default(),
1607 ));
1608 (map $arg:ident ty) => (reencoder.val_type($arg)?);
1609 (map $arg:ident hty) => (reencoder.heap_type($arg)?);
1610 (map $arg:ident from_ref_type) => (reencoder.ref_type($arg)?);
1611 (map $arg:ident to_ref_type) => (reencoder.ref_type($arg)?);
1612 (map $arg:ident memarg) => (reencoder.mem_arg($arg));
1613 (map $arg:ident ordering) => (reencoder.ordering($arg));
1614 (map $arg:ident local_index) => ($arg);
1615 (map $arg:ident value) => ($arg);
1616 (map $arg:ident lane) => ($arg);
1617 (map $arg:ident lanes) => ($arg);
1618 (map $arg:ident array_size) => ($arg);
1619 (map $arg:ident field_index) => ($arg);
1620 (map $arg:ident try_table) => ($arg);
1621 (map $arg:ident argument_index) => (reencoder.type_index($arg));
1622 (map $arg:ident result_index) => (reencoder.type_index($arg));
1623 (map $arg:ident cont_type_index) => (reencoder.type_index($arg));
1624 (map $arg:ident resume_table) => ((
1625 $arg.handlers.into_iter().map(|h| reencoder.handle(h)).collect::<Vec<_>>().into()
1626 ));
1627
1628 // This case takes the arguments of a wasmparser instruction and creates
1629 // a wasm-encoder instruction. There are a few special cases for where
1630 // the structure of a wasmparser instruction differs from that of
1631 // wasm-encoder.
1632 (build $op:ident) => (Instruction::$op);
1633 (build BrTable $arg:ident) => (Instruction::BrTable($arg.0, $arg.1));
1634 (build I32Const $arg:ident) => (Instruction::I32Const($arg));
1635 (build I64Const $arg:ident) => (Instruction::I64Const($arg));
1636 (build F32Const $arg:ident) => (Instruction::F32Const(f32::from_bits($arg.bits())));
1637 (build F64Const $arg:ident) => (Instruction::F64Const(f64::from_bits($arg.bits())));
1638 (build V128Const $arg:ident) => (Instruction::V128Const($arg.i128()));
1639 (build TryTable $table:ident) => (Instruction::TryTable(reencoder.block_type($table.ty)?, {
1640 $table.catches.into_iter().map(|c| reencoder.catch(c)).collect::<Vec<_>>().into()
1641 }));
1642 (build $op:ident $arg:ident) => (Instruction::$op($arg));
1643 (build $op:ident $($arg:ident)*) => (Instruction::$op { $($arg),* });
1644 }
1645
1646 wasmparser::for_each_operator!(translate)
1647 }
1648
1649 /// Parses the input `section` given from the `wasmparser` crate and adds
1650 /// all the code to the `code` section.
1651 pub fn parse_code_section<T: ?Sized + Reencode>(
1652 reencoder: &mut T,
1653 code: &mut crate::CodeSection,
1654 section: wasmparser::CodeSectionReader<'_>,
1655 ) -> Result<(), Error<T::Error>> {
1656 for func in section {
1657 reencoder.parse_function_body(code, func?)?;
1658 }
1659 Ok(())
1660 }
1661
1662 /// Parses a single [`wasmparser::FunctionBody`] and adds it to the `code` section.
1663 pub fn parse_function_body<T: ?Sized + Reencode>(
1664 reencoder: &mut T,
1665 code: &mut crate::CodeSection,
1666 func: wasmparser::FunctionBody<'_>,
1667 ) -> Result<(), Error<T::Error>> {
1668 let mut f = reencoder.new_function_with_parsed_locals(&func)?;
1669 let mut reader = func.get_operators_reader()?;
1670 while !reader.eof() {
1671 f.instruction(&reencoder.parse_instruction(&mut reader)?);
1672 }
1673 code.function(&f);
1674 Ok(())
1675 }
1676
1677 /// Create a new [`crate::Function`] by parsing the locals declarations from the
1678 /// provided [`wasmparser::FunctionBody`].
1679 pub fn new_function_with_parsed_locals<T: ?Sized + Reencode>(
1680 reencoder: &mut T,
1681 func: &wasmparser::FunctionBody<'_>,
1682 ) -> Result<crate::Function, Error<T::Error>> {
1683 let mut locals = Vec::new();
1684 for pair in func.get_locals_reader()? {
1685 let (cnt, ty) = pair?;
1686 locals.push((cnt, reencoder.val_type(ty)?));
1687 }
1688 Ok(crate::Function::new(locals))
1689 }
1690
1691 /// Parses a single instruction from `reader` and adds it to `function`.
1692 pub fn parse_instruction<'a, T: ?Sized + Reencode>(
1693 reencoder: &mut T,
1694 reader: &mut wasmparser::OperatorsReader<'a>,
1695 ) -> Result<crate::Instruction<'a>, Error<T::Error>> {
1696 let instruction = reencoder.instruction(reader.read()?)?;
1697 Ok(instruction)
1698 }
1699
1700 pub fn parse_unknown_section<T: ?Sized + Reencode>(
1701 _reencoder: &mut T,
1702 module: &mut crate::Module,
1703 id: u8,
1704 contents: &[u8],
1705 ) -> Result<(), Error<T::Error>> {
1706 module.section(&crate::RawSection { id, data: contents });
1707 Ok(())
1708 }
1709
1710 pub fn custom_name_section<T: ?Sized + Reencode>(
1711 reencoder: &mut T,
1712 section: wasmparser::NameSectionReader<'_>,
1713 ) -> Result<crate::NameSection, Error<T::Error>> {
1714 let mut ret = crate::NameSection::new();
1715 for subsection in section {
1716 reencoder.parse_custom_name_subsection(&mut ret, subsection?)?;
1717 }
1718 Ok(ret)
1719 }
1720
1721 pub fn parse_custom_name_subsection<T: ?Sized + Reencode>(
1722 reencoder: &mut T,
1723 names: &mut crate::NameSection,
1724 section: wasmparser::Name<'_>,
1725 ) -> Result<(), Error<T::Error>> {
1726 match section {
1727 wasmparser::Name::Module { name, .. } => {
1728 names.module(name);
1729 }
1730 wasmparser::Name::Function(map) => {
1731 names.functions(&name_map(map, |i| reencoder.function_index(i))?);
1732 }
1733 wasmparser::Name::Type(map) => {
1734 names.types(&name_map(map, |i| reencoder.type_index(i))?);
1735 }
1736 wasmparser::Name::Local(map) => {
1737 names.locals(&indirect_name_map(map, |i| reencoder.function_index(i))?);
1738 }
1739 wasmparser::Name::Label(map) => {
1740 names.labels(&indirect_name_map(map, |i| reencoder.function_index(i))?);
1741 }
1742 wasmparser::Name::Table(map) => {
1743 names.tables(&name_map(map, |i| reencoder.table_index(i))?);
1744 }
1745 wasmparser::Name::Memory(map) => {
1746 names.memories(&name_map(map, |i| reencoder.memory_index(i))?);
1747 }
1748 wasmparser::Name::Global(map) => {
1749 names.globals(&name_map(map, |i| reencoder.global_index(i))?);
1750 }
1751 wasmparser::Name::Element(map) => {
1752 names.elements(&name_map(map, |i| reencoder.element_index(i))?);
1753 }
1754 wasmparser::Name::Data(map) => {
1755 names.data(&name_map(map, |i| reencoder.data_index(i))?);
1756 }
1757 wasmparser::Name::Tag(map) => {
1758 names.tags(&name_map(map, |i| reencoder.tag_index(i))?);
1759 }
1760 wasmparser::Name::Field(map) => {
1761 names.fields(&indirect_name_map(map, |i| reencoder.type_index(i))?);
1762 }
1763 wasmparser::Name::Unknown { ty, data, .. } => {
1764 names.raw(ty, data);
1765 }
1766 }
1767 Ok(())
1768 }
1769
1770 pub fn name_map(
1771 map: wasmparser::NameMap<'_>,
1772 mut map_index: impl FnMut(u32) -> u32,
1773 ) -> wasmparser::Result<crate::NameMap> {
1774 let mut ret = crate::NameMap::new();
1775 for naming in map {
1776 let naming = naming?;
1777 ret.append(map_index(naming.index), naming.name);
1778 }
1779 Ok(ret)
1780 }
1781
1782 pub fn indirect_name_map(
1783 map: wasmparser::IndirectNameMap<'_>,
1784 mut map_index: impl FnMut(u32) -> u32,
1785 ) -> wasmparser::Result<crate::IndirectNameMap> {
1786 let mut ret = crate::IndirectNameMap::new();
1787 for naming in map {
1788 let naming = naming?;
1789 ret.append(map_index(naming.index), &name_map(naming.names, |i| i)?);
1790 }
1791 Ok(ret)
1792 }
1793}
1794
1795impl From<wasmparser::MemArg> for crate::MemArg {
1796 fn from(arg: wasmparser::MemArg) -> Self {
1797 RoundtripReencoder.mem_arg(arg)
1798 }
1799}
1800
1801impl From<wasmparser::Ordering> for crate::Ordering {
1802 fn from(arg: wasmparser::Ordering) -> Self {
1803 RoundtripReencoder.ordering(arg)
1804 }
1805}
1806
1807impl TryFrom<wasmparser::BlockType> for crate::BlockType {
1808 type Error = Error;
1809
1810 fn try_from(arg: wasmparser::BlockType) -> Result<Self, Self::Error> {
1811 RoundtripReencoder.block_type(arg)
1812 }
1813}
1814
1815impl<'a> TryFrom<wasmparser::Operator<'a>> for crate::Instruction<'a> {
1816 type Error = Error;
1817
1818 fn try_from(arg: wasmparser::Operator<'a>) -> Result<Self, Self::Error> {
1819 RoundtripReencoder.instruction(arg)
1820 }
1821}
1822
1823impl From<wasmparser::Catch> for crate::Catch {
1824 fn from(arg: wasmparser::Catch) -> Self {
1825 RoundtripReencoder.catch(arg)
1826 }
1827}
1828
1829impl<'a> TryFrom<wasmparser::ConstExpr<'a>> for crate::ConstExpr {
1830 type Error = Error;
1831
1832 fn try_from(const_expr: wasmparser::ConstExpr) -> Result<Self, Self::Error> {
1833 RoundtripReencoder.const_expr(const_expr)
1834 }
1835}
1836
1837impl<'a> From<wasmparser::CustomSectionReader<'a>> for crate::CustomSection<'a> {
1838 fn from(section: wasmparser::CustomSectionReader<'a>) -> Self {
1839 RoundtripReencoder.custom_section(section)
1840 }
1841}
1842
1843impl From<wasmparser::ExternalKind> for crate::ExportKind {
1844 fn from(external_kind: wasmparser::ExternalKind) -> Self {
1845 RoundtripReencoder.export_kind(external_kind)
1846 }
1847}
1848
1849impl TryFrom<wasmparser::GlobalType> for crate::GlobalType {
1850 type Error = Error;
1851
1852 fn try_from(global_ty: wasmparser::GlobalType) -> Result<Self, Self::Error> {
1853 RoundtripReencoder.global_type(global_ty)
1854 }
1855}
1856
1857impl From<wasmparser::Handle> for crate::Handle {
1858 fn from(arg: wasmparser::Handle) -> Self {
1859 RoundtripReencoder.handle(on:arg)
1860 }
1861}
1862
1863impl TryFrom<wasmparser::TypeRef> for crate::EntityType {
1864 type Error = Error;
1865
1866 fn try_from(type_ref: wasmparser::TypeRef) -> Result<Self, Self::Error> {
1867 RoundtripReencoder.entity_type(type_ref)
1868 }
1869}
1870
1871impl From<wasmparser::MemoryType> for crate::MemoryType {
1872 fn from(memory_ty: wasmparser::MemoryType) -> Self {
1873 RoundtripReencoder.memory_type(memory_ty)
1874 }
1875}
1876
1877impl TryFrom<wasmparser::TableType> for crate::TableType {
1878 type Error = Error;
1879
1880 fn try_from(table_ty: wasmparser::TableType) -> Result<Self, Self::Error> {
1881 RoundtripReencoder.table_type(table_ty)
1882 }
1883}
1884
1885impl From<wasmparser::TagKind> for crate::TagKind {
1886 fn from(kind: wasmparser::TagKind) -> Self {
1887 RoundtripReencoder.tag_kind(kind)
1888 }
1889}
1890
1891impl From<wasmparser::TagType> for crate::TagType {
1892 fn from(tag_ty: wasmparser::TagType) -> Self {
1893 RoundtripReencoder.tag_type(tag_ty)
1894 }
1895}
1896
1897impl TryFrom<wasmparser::SubType> for crate::SubType {
1898 type Error = Error;
1899
1900 fn try_from(sub_ty: wasmparser::SubType) -> Result<Self, Self::Error> {
1901 RoundtripReencoder.sub_type(sub_ty)
1902 }
1903}
1904
1905impl TryFrom<wasmparser::CompositeType> for crate::CompositeType {
1906 type Error = Error;
1907
1908 fn try_from(composite_ty: wasmparser::CompositeType) -> Result<Self, Self::Error> {
1909 RoundtripReencoder.composite_type(composite_ty)
1910 }
1911}
1912
1913impl TryFrom<wasmparser::FuncType> for crate::FuncType {
1914 type Error = Error;
1915
1916 fn try_from(func_ty: wasmparser::FuncType) -> Result<Self, Self::Error> {
1917 RoundtripReencoder.func_type(func_ty)
1918 }
1919}
1920
1921impl TryFrom<wasmparser::ArrayType> for crate::ArrayType {
1922 type Error = Error;
1923
1924 fn try_from(array_ty: wasmparser::ArrayType) -> Result<Self, Self::Error> {
1925 RoundtripReencoder.array_type(array_ty)
1926 }
1927}
1928
1929impl TryFrom<wasmparser::StructType> for crate::StructType {
1930 type Error = Error;
1931
1932 fn try_from(struct_ty: wasmparser::StructType) -> Result<Self, Self::Error> {
1933 RoundtripReencoder.struct_type(struct_ty)
1934 }
1935}
1936
1937impl TryFrom<wasmparser::FieldType> for crate::FieldType {
1938 type Error = Error;
1939
1940 fn try_from(field_ty: wasmparser::FieldType) -> Result<Self, Self::Error> {
1941 RoundtripReencoder.field_type(field_ty)
1942 }
1943}
1944
1945impl TryFrom<wasmparser::StorageType> for crate::StorageType {
1946 type Error = Error;
1947
1948 fn try_from(storage_ty: wasmparser::StorageType) -> Result<Self, Self::Error> {
1949 RoundtripReencoder.storage_type(storage_ty)
1950 }
1951}
1952
1953impl TryFrom<wasmparser::ValType> for crate::ValType {
1954 type Error = Error;
1955
1956 fn try_from(val_ty: wasmparser::ValType) -> Result<Self, Self::Error> {
1957 RoundtripReencoder.val_type(val_ty)
1958 }
1959}
1960
1961impl TryFrom<wasmparser::RefType> for crate::RefType {
1962 type Error = Error;
1963
1964 fn try_from(ref_type: wasmparser::RefType) -> Result<Self, Self::Error> {
1965 RoundtripReencoder.ref_type(ref_type)
1966 }
1967}
1968
1969impl TryFrom<wasmparser::HeapType> for crate::HeapType {
1970 type Error = Error;
1971
1972 fn try_from(heap_type: wasmparser::HeapType) -> Result<Self, Self::Error> {
1973 crate::reencode::utils::heap_type(&mut crate::reencode::RoundtripReencoder, heap_type)
1974 }
1975}
1976
1977impl From<wasmparser::AbstractHeapType> for crate::AbstractHeapType {
1978 fn from(value: wasmparser::AbstractHeapType) -> Self {
1979 RoundtripReencoder.abstract_heap_type(value)
1980 }
1981}
1982