nandi.uk
Fork of daniellemaywood.uk/gleam — Wasm codegen work
29 kB
774 lines
1#![allow(clippy::unnecessary_wraps)] // Needed for macro
2
3use capnp::{text, text_list};
4use ecow::EcoString;
5use itertools::Itertools;
6
7use crate::{
8 Result,
9 analyse::Inferred,
10 ast::{
11 BitArrayOption, BitArraySegment, CallArg, Constant, Publicity, SrcSpan, TypedConstant,
12 TypedConstantBitArraySegment, TypedConstantBitArraySegmentOption,
13 },
14 build::Origin,
15 line_numbers::{Character, LineNumbers},
16 parse::LiteralFloatValue,
17 reference::{Reference, ReferenceKind, ReferenceMap},
18 schema_capnp::{self as schema, *},
19 type_::{
20 self, AccessorsMap, Deprecation, FieldMap, ModuleInterface, Opaque, RecordAccessor,
21 References, Type, TypeAliasConstructor, TypeConstructor, TypeValueConstructor,
22 TypeValueConstructorField, TypeVariantConstructors, ValueConstructor,
23 ValueConstructorVariant,
24 expression::{Implementations, Purity},
25 },
26 uid::UniqueIdGenerator,
27};
28use std::{collections::HashMap, collections::HashSet, io::BufRead, sync::Arc};
29
30macro_rules! read_vec {
31 ($reader:expr, $self:expr, $method:ident) => {{
32 let reader = $reader;
33 let mut vec = Vec::with_capacity(reader.len() as usize);
34 for reader in reader.into_iter() {
35 let value = $self.$method(&reader)?;
36 vec.push(value);
37 }
38 vec
39 }};
40}
41
42macro_rules! read_hashmap {
43 ($reader:expr, $self:expr, $method:ident) => {{
44 let reader = $reader;
45 let mut map = HashMap::with_capacity(reader.len() as usize);
46 for prop in reader.into_iter() {
47 let name = $self.string(prop.get_key()?)?;
48 let values = $self.$method(&prop.get_value()?.into())?;
49 let _ = map.insert(name, values);
50 }
51 map
52 }};
53}
54
55#[derive(Debug)]
56pub struct ModuleDecoder {
57 ids: UniqueIdGenerator,
58 type_var_id_map: HashMap<u64, u64>,
59}
60
61impl ModuleDecoder {
62 pub fn new(ids: UniqueIdGenerator) -> Self {
63 Self {
64 ids,
65 type_var_id_map: Default::default(),
66 }
67 }
68
69 pub fn read(&mut self, reader: impl BufRead) -> Result<ModuleInterface> {
70 let message_reader =
71 capnp::serialize_packed::read_message(reader, capnp::message::ReaderOptions::new())?;
72 let reader = message_reader.get_root::<module::Reader<'_>>()?;
73
74 Ok(ModuleInterface {
75 name: self.string(reader.get_name()?)?,
76 package: self.string(reader.get_package()?)?,
77 is_internal: reader.get_is_internal(),
78 origin: Origin::Src,
79 values: read_hashmap!(reader.get_values()?, self, value_constructor),
80 types: read_hashmap!(reader.get_types()?, self, type_constructor),
81 types_value_constructors: read_hashmap!(
82 reader.get_types_constructors()?,
83 self,
84 type_variants_constructors
85 ),
86 accessors: read_hashmap!(reader.get_accessors()?, self, accessors_map),
87 line_numbers: self.line_numbers(&reader.get_line_numbers()?)?,
88 src_path: self.str(reader.get_src_path()?)?.into(),
89 warnings: vec![],
90 minimum_required_version: self.version(&reader.get_required_version()?),
91 type_aliases: read_hashmap!(reader.get_type_aliases()?, self, type_alias_constructor),
92 documentation: self.string_list(reader.get_documentation()?)?,
93 contains_echo: reader.get_contains_echo(),
94 references: self.references(reader.get_references()?)?,
95 inline_functions: HashMap::new(),
96 })
97 }
98
99 fn string(&self, reader: text::Reader<'_>) -> Result<EcoString> {
100 self.str(reader).map(|str| str.into())
101 }
102
103 fn string_list(&self, reader: text_list::Reader<'_>) -> Result<Vec<EcoString>> {
104 let mut vec = Vec::with_capacity(reader.len() as usize);
105 for reader in reader.into_iter() {
106 vec.push(self.string(reader?)?);
107 }
108 Ok(vec)
109 }
110
111 fn str<'a>(&self, reader: text::Reader<'a>) -> Result<&'a str> {
112 reader
113 .to_str()
114 .map_err(|_| capnp::Error::failed("String contains non-utf8 characters".into()).into())
115 }
116
117 fn references(&self, reader: references::Reader<'_>) -> Result<References> {
118 Ok(References {
119 imported_modules: self.string_set(reader.get_imported_modules()?)?,
120 value_references: self.reference_map(reader.get_value_references()?)?,
121 type_references: self.reference_map(reader.get_type_references()?)?,
122 })
123 }
124
125 fn string_set(&self, reader: text_list::Reader<'_>) -> Result<HashSet<EcoString>> {
126 let mut set = HashSet::with_capacity(reader.len() as usize);
127 for reader in reader.into_iter() {
128 let _ = set.insert(self.string(reader?)?);
129 }
130 Ok(set)
131 }
132
133 fn reference_map(
134 &self,
135 reader: capnp::struct_list::Reader<'_, reference_map::Owned>,
136 ) -> Result<ReferenceMap> {
137 let mut map = HashMap::with_capacity(reader.len() as usize);
138 for prop in reader.into_iter() {
139 let module = self.string(prop.get_module()?)?;
140 let name = self.string(prop.get_name()?)?;
141 let references = read_vec!(prop.get_references()?, self, reference);
142 let _ = map.insert((module, name), references);
143 }
144 Ok(map)
145 }
146
147 fn reference(&self, reader: &reference::Reader<'_>) -> Result<Reference> {
148 Ok(Reference {
149 location: self.src_span(&reader.get_location()?)?,
150 kind: self.reference_kind(&reader.get_kind()?)?,
151 })
152 }
153
154 fn reference_kind(&self, reader: &reference_kind::Reader<'_>) -> Result<ReferenceKind> {
155 use reference_kind::Which;
156 Ok(match reader.which()? {
157 Which::Qualified(_) => ReferenceKind::Qualified,
158 Which::Unqualified(_) => ReferenceKind::Unqualified,
159 Which::Import(_) => ReferenceKind::Import,
160 Which::Definition(_) => ReferenceKind::Definition,
161 Which::Alias(_) => ReferenceKind::Alias,
162 })
163 }
164
165 fn type_constructor(
166 &mut self,
167 reader: &type_constructor::Reader<'_>,
168 ) -> Result<TypeConstructor> {
169 let type_ = self.type_(&reader.get_type()?)?;
170 let deprecation = reader.get_deprecated()?;
171 let deprecation = if deprecation.is_empty() {
172 Deprecation::NotDeprecated
173 } else {
174 Deprecation::Deprecated {
175 message: self.string(deprecation)?,
176 }
177 };
178 Ok(TypeConstructor {
179 publicity: self.publicity(reader.get_publicity()?)?,
180 origin: self.src_span(&reader.get_origin()?)?,
181 module: self.string(reader.get_module()?)?,
182 parameters: read_vec!(reader.get_parameters()?, self, type_),
183 type_,
184 deprecation,
185 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
186 })
187 }
188
189 fn type_alias_constructor(
190 &mut self,
191 reader: &type_alias_constructor::Reader<'_>,
192 ) -> Result<TypeAliasConstructor> {
193 let type_ = self.type_(&reader.get_type()?)?;
194 let deprecation = reader.get_deprecation()?;
195 let deprecation = if deprecation.is_empty() {
196 Deprecation::NotDeprecated
197 } else {
198 Deprecation::Deprecated {
199 message: self.string(deprecation)?,
200 }
201 };
202 let parameters = read_vec!(&reader.get_parameters()?, self, type_);
203 Ok(TypeAliasConstructor {
204 publicity: self.publicity(reader.get_publicity()?)?,
205 origin: self.src_span(&reader.get_origin()?)?,
206 module: self.string(reader.get_module()?)?,
207 type_,
208 deprecation,
209 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
210 arity: reader.get_arity() as usize,
211 parameters,
212 })
213 }
214
215 fn type_(&mut self, reader: &schema::type_::Reader<'_>) -> Result<Arc<Type>> {
216 use schema::type_::Which;
217 match reader.which()? {
218 Which::App(reader) => self.type_app(&reader),
219 Which::Fn(reader) => self.type_fn(&reader),
220 Which::Tuple(reader) => self.type_tuple(&reader),
221 Which::Var(reader) => self.type_var(&reader),
222 }
223 }
224
225 fn type_app(&mut self, reader: &schema::type_::app::Reader<'_>) -> Result<Arc<Type>> {
226 let package = self.string(reader.get_package()?)?;
227 let module = self.string(reader.get_module()?)?;
228 let name = self.string(reader.get_name()?)?;
229 let arguments = read_vec!(&reader.get_parameters()?, self, type_);
230 let inferred_variant = self.inferred_variant(&reader.get_inferred_variant()?)?;
231 let publicity = self.publicity(reader.get_publicity()?)?;
232
233 Ok(Arc::new(Type::Named {
234 publicity,
235 package,
236 module,
237 name,
238 arguments,
239 inferred_variant,
240 }))
241 }
242
243 fn type_fn(&mut self, reader: &schema::type_::fn_::Reader<'_>) -> Result<Arc<Type>> {
244 let return_ = self.type_(&reader.get_return()?)?;
245 let arguments = read_vec!(&reader.get_arguments()?, self, type_);
246 Ok(Arc::new(Type::Fn { arguments, return_ }))
247 }
248
249 fn type_tuple(&mut self, reader: &schema::type_::tuple::Reader<'_>) -> Result<Arc<Type>> {
250 let elements = read_vec!(&reader.get_elements()?, self, type_);
251 Ok(Arc::new(Type::Tuple { elements }))
252 }
253
254 fn type_var(&mut self, reader: &schema::type_::var::Reader<'_>) -> Result<Arc<Type>> {
255 let serialized_id = reader.get_id();
256 let id = self.get_or_insert_type_var_id(serialized_id);
257 Ok(type_::generic_var(id))
258 }
259
260 fn get_or_insert_type_var_id(&mut self, id: u64) -> u64 {
261 match self.type_var_id_map.get(&id) {
262 Some(&id) => id,
263 None => {
264 let new_id = self.ids.next();
265 let _ = self.type_var_id_map.insert(id, new_id);
266 new_id
267 }
268 }
269 }
270
271 fn type_variants_constructors(
272 &mut self,
273 reader: &types_variant_constructors::Reader<'_>,
274 ) -> Result<TypeVariantConstructors> {
275 let variants = reader
276 .get_variants()?
277 .iter()
278 .map(|r| self.type_value_constructor(&r))
279 .try_collect()?;
280 let type_parameters_ids = read_vec!(
281 reader.get_type_parameters_ids()?,
282 self,
283 type_variant_constructor_type_parameter_id
284 );
285 let opaque = if reader.get_opaque() {
286 Opaque::Opaque
287 } else {
288 Opaque::NotOpaque
289 };
290
291 Ok(TypeVariantConstructors {
292 variants,
293 type_parameters_ids,
294 opaque,
295 })
296 }
297
298 fn type_variant_constructor_type_parameter_id(&mut self, i: &u16) -> Result<u64> {
299 Ok(self.get_or_insert_type_var_id(*i as u64))
300 }
301
302 fn type_value_constructor(
303 &mut self,
304 reader: &type_value_constructor::Reader<'_>,
305 ) -> Result<TypeValueConstructor> {
306 Ok(TypeValueConstructor {
307 name: self.string(reader.get_name()?)?,
308 parameters: read_vec!(
309 reader.get_parameters()?,
310 self,
311 type_value_constructor_parameter
312 ),
313 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
314 })
315 }
316
317 fn type_value_constructor_parameter(
318 &mut self,
319 reader: &type_value_constructor_parameter::Reader<'_>,
320 ) -> Result<TypeValueConstructorField> {
321 Ok(TypeValueConstructorField {
322 type_: self.type_(&reader.get_type()?)?,
323 label: self.optional_string(self.str(reader.get_label()?)?),
324 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
325 })
326 }
327
328 fn inferred_variant(&mut self, reader: &inferred_variant::Reader<'_>) -> Result<Option<u16>> {
329 use schema::inferred_variant::Which;
330 match reader.which()? {
331 Which::Unknown(_) => Ok(None),
332 Which::Inferred(variant) => Ok(Some(variant)),
333 }
334 }
335
336 fn value_constructor(
337 &mut self,
338 reader: &value_constructor::Reader<'_>,
339 ) -> Result<ValueConstructor> {
340 let type_ = self.type_(&reader.get_type()?)?;
341 let variant = self.value_constructor_variant(&reader.get_variant()?)?;
342 let publicity = self.publicity(reader.get_publicity()?)?;
343 let deprecation = reader.get_deprecated()?;
344 let deprecation = if deprecation.is_empty() {
345 Deprecation::NotDeprecated
346 } else {
347 Deprecation::Deprecated {
348 message: self.string(deprecation)?,
349 }
350 };
351 Ok(ValueConstructor {
352 deprecation,
353 publicity,
354 type_,
355 variant,
356 })
357 }
358
359 fn publicity(&self, reader: publicity::Reader<'_>) -> Result<Publicity> {
360 match reader.which()? {
361 publicity::Which::Public(()) => Ok(Publicity::Public),
362 publicity::Which::Private(()) => Ok(Publicity::Private),
363 publicity::Which::Internal(reader) => match reader?.which()? {
364 option::Which::None(()) => Ok(Publicity::Internal {
365 attribute_location: None,
366 }),
367 option::Which::Some(reader) => Ok(Publicity::Internal {
368 attribute_location: Some(self.src_span(&reader?)?),
369 }),
370 },
371 }
372 }
373
374 fn constant(&mut self, reader: &constant::Reader<'_>) -> Result<TypedConstant> {
375 use constant::Which;
376 match reader.which()? {
377 Which::Int(reader) => Ok(self.constant_int(self.str(reader?)?)),
378 Which::Float(reader) => Ok(self.constant_float(self.str(reader?)?)),
379 Which::String(reader) => Ok(self.constant_string(self.str(reader?)?)),
380 Which::Tuple(reader) => self.constant_tuple(&reader),
381 Which::List(reader) => self.constant_list(&reader),
382 Which::Record(reader) => self.constant_record(&reader),
383 Which::BitArray(reader) => self.constant_bit_array(&reader?),
384 Which::Var(reader) => self.constant_var(&reader),
385 Which::StringConcatenation(reader) => self.constant_string_concatenation(&reader),
386 }
387 }
388
389 fn constant_int(&self, value: &str) -> TypedConstant {
390 Constant::Int {
391 location: Default::default(),
392 value: value.into(),
393 int_value: crate::parse::parse_int_value(value).expect("int value to parse as bigint"),
394 }
395 }
396
397 fn constant_float(&self, value: &str) -> TypedConstant {
398 Constant::Float {
399 location: Default::default(),
400 value: value.into(),
401 float_value: LiteralFloatValue::parse(value)
402 .expect("float value to parse as non-NaN f64"),
403 }
404 }
405
406 fn constant_string(&self, value: &str) -> TypedConstant {
407 Constant::String {
408 location: Default::default(),
409 value: value.into(),
410 }
411 }
412
413 fn constant_tuple(&mut self, reader: &constant::tuple::Reader<'_>) -> Result<TypedConstant> {
414 let type_ = self.type_(&reader.get_type()?)?;
415 Ok(Constant::Tuple {
416 location: Default::default(),
417 elements: read_vec!(reader.get_elements()?, self, constant),
418 type_,
419 })
420 }
421
422 fn constant_list(&mut self, reader: &constant::list::Reader<'_>) -> Result<TypedConstant> {
423 let type_ = self.type_(&reader.get_type()?)?;
424 Ok(Constant::List {
425 location: Default::default(),
426 elements: read_vec!(reader.get_elements()?, self, constant),
427 type_,
428 })
429 }
430
431 fn constant_record(&mut self, reader: &constant::record::Reader<'_>) -> Result<TypedConstant> {
432 let type_ = self.type_(&reader.get_type()?)?;
433 let tag = self.string(reader.get_tag()?)?;
434 let arguments = read_vec!(reader.get_args()?, self, constant_call_arg);
435 Ok(Constant::Record {
436 location: Default::default(),
437 module: Default::default(),
438 name: Default::default(),
439 arguments,
440 tag,
441 type_,
442 field_map: Inferred::Unknown,
443 record_constructor: None,
444 })
445 }
446
447 fn constant_call_arg(
448 &mut self,
449 reader: &constant::Reader<'_>,
450 ) -> Result<CallArg<TypedConstant>> {
451 Ok(CallArg {
452 implicit: None,
453 label: Default::default(),
454 location: Default::default(),
455 value: self.constant(reader)?,
456 })
457 }
458
459 fn constant_bit_array(
460 &mut self,
461 reader: &capnp::struct_list::Reader<'_, bit_array_segment::Owned>,
462 ) -> Result<TypedConstant> {
463 Ok(Constant::BitArray {
464 location: Default::default(),
465 segments: read_vec!(reader, self, bit_array_segment),
466 })
467 }
468
469 fn constant_var(&mut self, reader: &constant::var::Reader<'_>) -> Result<TypedConstant> {
470 let type_ = self.type_(&reader.get_type()?)?;
471 let module = self.optional_string(self.str(reader.get_module()?)?);
472 let name = reader.get_name()?;
473 let constructor = self.value_constructor(&reader.get_constructor()?)?;
474 Ok(Constant::Var {
475 location: Default::default(),
476 module: module.map(|module| (module, Default::default())),
477 name: self.string(name)?,
478 constructor: Some(Box::from(constructor)),
479 type_,
480 })
481 }
482
483 fn constant_string_concatenation(
484 &mut self,
485 reader: &constant::string_concatenation::Reader<'_>,
486 ) -> Result<TypedConstant> {
487 Ok(Constant::StringConcatenation {
488 location: Default::default(),
489 left: Box::new(self.constant(&reader.get_left()?)?),
490 right: Box::new(self.constant(&reader.get_right()?)?),
491 })
492 }
493
494 fn bit_array_segment(
495 &mut self,
496 reader: &bit_array_segment::Reader<'_>,
497 ) -> Result<TypedConstantBitArraySegment> {
498 Ok(BitArraySegment {
499 location: Default::default(),
500 type_: self.type_(&reader.get_type()?)?,
501 value: Box::new(self.constant(&reader.get_value()?)?),
502 options: read_vec!(reader.get_options()?, self, bit_array_segment_option),
503 })
504 }
505
506 fn bit_array_segment_option(
507 &mut self,
508 reader: &bit_array_segment_option::Reader<'_>,
509 ) -> Result<TypedConstantBitArraySegmentOption> {
510 use bit_array_segment_option::Which;
511 Ok(match reader.which()? {
512 Which::Bytes(_) => BitArrayOption::Bytes {
513 location: Default::default(),
514 },
515 Which::Integer(_) => BitArrayOption::Int {
516 location: Default::default(),
517 },
518 Which::Float(_) => BitArrayOption::Float {
519 location: Default::default(),
520 },
521 Which::Bits(_) => BitArrayOption::Bits {
522 location: Default::default(),
523 },
524 Which::Utf8(_) => BitArrayOption::Utf8 {
525 location: Default::default(),
526 },
527 Which::Utf16(_) => BitArrayOption::Utf16 {
528 location: Default::default(),
529 },
530 Which::Utf32(_) => BitArrayOption::Utf32 {
531 location: Default::default(),
532 },
533 Which::Utf8Codepoint(_) => BitArrayOption::Utf8Codepoint {
534 location: Default::default(),
535 },
536 Which::Utf16Codepoint(_) => BitArrayOption::Utf16Codepoint {
537 location: Default::default(),
538 },
539 Which::Utf32Codepoint(_) => BitArrayOption::Utf32Codepoint {
540 location: Default::default(),
541 },
542 Which::Signed(_) => BitArrayOption::Signed {
543 location: Default::default(),
544 },
545 Which::Unsigned(_) => BitArrayOption::Unsigned {
546 location: Default::default(),
547 },
548 Which::Big(_) => BitArrayOption::Big {
549 location: Default::default(),
550 },
551 Which::Little(_) => BitArrayOption::Little {
552 location: Default::default(),
553 },
554 Which::Native(_) => BitArrayOption::Native {
555 location: Default::default(),
556 },
557 Which::Size(reader) => BitArrayOption::Size {
558 location: Default::default(),
559 short_form: reader.get_short_form(),
560 value: Box::new(self.constant(&reader.get_value()?)?),
561 },
562 Which::Unit(reader) => BitArrayOption::Unit {
563 location: Default::default(),
564 value: reader.get_value(),
565 },
566 })
567 }
568
569 fn value_constructor_variant(
570 &mut self,
571 reader: &value_constructor_variant::Reader<'_>,
572 ) -> Result<ValueConstructorVariant> {
573 use value_constructor_variant::Which;
574 match reader.which()? {
575 Which::ModuleConstant(reader) => self.module_constant_variant(&reader),
576 Which::ModuleFn(reader) => self.module_fn_variant(&reader),
577 Which::Record(reader) => self.record(&reader),
578 }
579 }
580
581 fn module_constant_variant(
582 &mut self,
583 reader: &value_constructor_variant::module_constant::Reader<'_>,
584 ) -> Result<ValueConstructorVariant> {
585 Ok(ValueConstructorVariant::ModuleConstant {
586 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
587 location: self.src_span(&reader.get_location()?)?,
588 literal: self.constant(&reader.get_literal()?)?,
589 module: self.string(reader.get_module()?)?,
590 name: self.string(reader.get_name()?)?,
591 implementations: self.implementations(reader.get_implementations()?),
592 })
593 }
594
595 fn optional_string(&self, str: &str) -> Option<EcoString> {
596 if str.is_empty() {
597 None
598 } else {
599 Some(str.into())
600 }
601 }
602
603 fn src_span(&self, reader: &src_span::Reader<'_>) -> Result<SrcSpan> {
604 Ok(SrcSpan {
605 start: reader.get_start(),
606 end: reader.get_end(),
607 })
608 }
609
610 fn module_fn_variant(
611 &self,
612 reader: &value_constructor_variant::module_fn::Reader<'_>,
613 ) -> Result<ValueConstructorVariant> {
614 let purity = match reader.get_purity()?.which()? {
615 purity::Which::Pure(()) => Purity::Pure,
616 purity::Which::TrustedPure(()) => Purity::TrustedPure,
617 purity::Which::Impure(()) => Purity::Impure,
618 purity::Which::Unknown(()) => Purity::Unknown,
619 };
620
621 Ok(ValueConstructorVariant::ModuleFn {
622 name: self.string(reader.get_name()?)?,
623 module: self.string(reader.get_module()?)?,
624 arity: reader.get_arity() as usize,
625 field_map: self.field_map(&reader.get_field_map()?)?,
626 location: self.src_span(&reader.get_location()?)?,
627 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
628 implementations: self.implementations(reader.get_implementations()?),
629 external_erlang: self.optional_external(reader.get_external_erlang()?)?,
630 external_javascript: self.optional_external(reader.get_external_javascript()?)?,
631 purity,
632 })
633 }
634
635 fn implementations(&self, reader: implementations::Reader<'_>) -> Implementations {
636 Implementations {
637 gleam: reader.get_gleam(),
638 uses_erlang_externals: reader.get_uses_erlang_externals(),
639 uses_javascript_externals: reader.get_uses_javascript_externals(),
640 can_run_on_erlang: reader.get_can_run_on_erlang(),
641 can_run_on_javascript: reader.get_can_run_on_javascript(),
642 }
643 }
644
645 fn record(
646 &self,
647 reader: &value_constructor_variant::record::Reader<'_>,
648 ) -> Result<ValueConstructorVariant> {
649 Ok(ValueConstructorVariant::Record {
650 name: self.string(reader.get_name()?)?,
651 module: self.string(reader.get_module()?)?,
652 arity: reader.get_arity(),
653 variants_count: reader.get_constructors_count(),
654 field_map: self.field_map(&reader.get_field_map()?)?,
655 location: self.src_span(&reader.get_location()?)?,
656 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
657 variant_index: reader.get_constructor_index(),
658 })
659 }
660
661 fn field_map(&self, reader: &option::Reader<'_, field_map::Owned>) -> Result<Option<FieldMap>> {
662 use option::Which;
663 Ok(match reader.which()? {
664 Which::None(_) => None,
665 Which::Some(reader) => Some({
666 let reader = reader?;
667 FieldMap {
668 arity: reader.get_arity(),
669 fields: read_hashmap!(&reader.get_fields()?, self, u32),
670 }
671 }),
672 })
673 }
674
675 fn u32(&self, i: &boxed_u_int32::Reader<'_>) -> Result<u32> {
676 Ok(i.get_value())
677 }
678
679 fn accessors_map(&mut self, reader: &accessors_map::Reader<'_>) -> Result<AccessorsMap> {
680 Ok(AccessorsMap {
681 publicity: self.publicity(reader.get_publicity()?)?,
682 type_: self.type_(&reader.get_type()?)?,
683 shared_accessors: read_hashmap!(&reader.get_shared_accessors()?, self, record_accessor),
684 variant_specific_accessors: read_vec!(
685 &reader.get_variant_specific_accessors()?,
686 self,
687 variant_specific_accessors
688 ),
689 variant_positional_accessors: read_vec!(
690 &reader.get_positional_accessors()?,
691 self,
692 positional_accessors
693 ),
694 })
695 }
696
697 fn variant_specific_accessors(
698 &mut self,
699 reader: &variant_specific_accessors::Reader<'_>,
700 ) -> Result<HashMap<EcoString, RecordAccessor>> {
701 Ok(read_hashmap!(
702 &reader.get_accessors()?,
703 self,
704 record_accessor
705 ))
706 }
707
708 fn positional_accessors(
709 &mut self,
710 reader: &positional_accessors::Reader<'_>,
711 ) -> Result<Vec<Arc<Type>>> {
712 Ok(read_vec!(&reader.get_accessors()?, self, type_))
713 }
714
715 fn record_accessor(&mut self, reader: &record_accessor::Reader<'_>) -> Result<RecordAccessor> {
716 Ok(RecordAccessor {
717 index: reader.get_index() as u64,
718 label: self.string(reader.get_label()?)?,
719 type_: self.type_(&reader.get_type()?)?,
720 documentation: self.optional_string(self.str(reader.get_documentation()?)?),
721 })
722 }
723
724 fn line_starts(&mut self, i: &u32) -> Result<u32> {
725 Ok(*i)
726 }
727
728 fn line_numbers(&mut self, reader: &line_numbers::Reader<'_>) -> Result<LineNumbers> {
729 Ok(LineNumbers {
730 length: reader.get_length(),
731 line_starts: read_vec!(reader.get_line_starts()?, self, line_starts),
732 mapping: self.mapping(reader.get_mapping()?),
733 })
734 }
735
736 fn mapping(
737 &self,
738 reader: capnp::struct_list::Reader<'_, character::Owned>,
739 ) -> HashMap<usize, Character> {
740 let mut map = HashMap::with_capacity(reader.len() as usize);
741 for character in reader.into_iter() {
742 let byte_index = character.get_byte_index() as usize;
743 let length_utf8 = character.get_length_utf8();
744 let length_utf16 = character.get_length_utf16();
745 _ = map.insert(
746 byte_index,
747 Character {
748 length_utf16,
749 length_utf8,
750 },
751 )
752 }
753 map
754 }
755
756 fn version(&self, reader: &version::Reader<'_>) -> hexpm::version::Version {
757 hexpm::version::Version::new(reader.get_major(), reader.get_minor(), reader.get_patch())
758 }
759
760 fn optional_external(
761 &self,
762 reader: option::Reader<'_, external::Owned>,
763 ) -> Result<Option<(EcoString, EcoString)>> {
764 match reader.which()? {
765 option::Which::None(()) => Ok(None),
766 option::Which::Some(reader) => {
767 let reader = reader?;
768 let module = self.string(reader.get_module()?)?;
769 let function = self.string(reader.get_function()?)?;
770 Ok(Some((module, function)))
771 }
772 }
773 }
774}