use a member enum to select the abi width

Author: cpetig

crates/wit-parser/src/sizealign.rs

@@ -1,80 +1,26 @@
 use crate::{FlagsRepr, Int, Resolve, Type, TypeDef, TypeDefKind};
 
-pub type SizeAlign = SizeAlignSelect;
-
-// Data type with construction selected variant
-pub enum SizeAlignSelect {
-    Wasm32(SizeAlignAbi<false>),
-    Wasm64(SizeAlignAbi<true>),
+#[derive(Default)]
+pub enum AddressSize {
+    #[default]
+    Wasm32,
+    Wasm64,
 }
 
-impl std::default::Default for SizeAlignSelect {
-    fn default() -> Self {
-        Self::Wasm32(Default::default())
-    }
+#[derive(Default)]
+pub struct SizeAlign {
+    map: Vec<(usize, usize)>,
+    wasm_type: AddressSize,
 }
 
-impl SizeAlignSelect {
-    pub fn fill(&mut self, resolve: &Resolve) {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.fill(resolve),
-            SizeAlignSelect::Wasm64(sna) => sna.fill(resolve),
-        }
-    }
-
-    pub fn size(&self, ty: &Type) -> usize {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.size(ty),
-            SizeAlignSelect::Wasm64(sna) => sna.size(ty),
-        }
-    }
-
-    pub fn align(&self, ty: &Type) -> usize {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.align(ty),
-            SizeAlignSelect::Wasm64(sna) => sna.align(ty),
-        }
-    }
-
-    pub fn record<'a>(&self, types: impl Iterator<Item = &'a Type>) -> (usize, usize) {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.record(types),
-            SizeAlignSelect::Wasm64(sna) => sna.record(types),
-        }
-    }
-
-    pub fn params<'a>(&self, types: impl IntoIterator<Item = &'a Type>) -> (usize, usize) {
-        self.record(types.into_iter())
-    }
-
-    pub fn field_offsets<'a>(
-        &self,
-        types: impl IntoIterator<Item = &'a Type>,
-    ) -> Vec<(usize, &'a Type)> {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.field_offsets(types),
-            SizeAlignSelect::Wasm64(sna) => sna.field_offsets(types),
+impl SizeAlign {
+    pub fn new(wasm_type: AddressSize) -> Self {
+        Self {
+            map: Vec::new(),
+            wasm_type,
         }
     }
 
-    pub fn payload_offset<'a>(
-        &self,
-        tag: Int,
-        cases: impl IntoIterator<Item = Option<&'a Type>>,
-    ) -> usize {
-        match self {
-            SizeAlignSelect::Wasm32(sna) => sna.payload_offset(tag, cases),
-            SizeAlignSelect::Wasm64(sna) => sna.payload_offset(tag, cases),
-        }
-    }
-}
-
-#[derive(Default)]
-pub struct SizeAlignAbi<const wasm64: bool> {
-    map: Vec<(usize, usize)>,
-}
-
-impl<const wasm64: bool> SizeAlignAbi<wasm64> {
     pub fn fill(&mut self, resolve: &Resolve) {
         self.map = Vec::new();
         for (_, ty) in resolve.types.iter() {
@@ -87,7 +33,7 @@ impl<const wasm64: bool> SizeAlignAbi<wasm64> {
         match &ty.kind {
             TypeDefKind::Type(t) => (self.size(t), self.align(t)),
             TypeDefKind::List(_) => {
-                if wasm64 {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
                     (16, 8)
                 } else {
                     (8, 4)
@@ -124,7 +70,7 @@ impl<const wasm64: bool> SizeAlignAbi<wasm64> {
             Type::U32 | Type::S32 | Type::Float32 | Type::Char => 4,
             Type::U64 | Type::S64 | Type::Float64 => 8,
             Type::String => {
-                if wasm64 {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
                     16
                 } else {
                     8
@@ -141,7 +87,7 @@ impl<const wasm64: bool> SizeAlignAbi<wasm64> {
             Type::U32 | Type::S32 | Type::Float32 | Type::Char => 4,
             Type::U64 | Type::S64 | Type::Float64 => 8,
             Type::String => {
-                if wasm64 {
+                if matches!(self.wasm_type, AddressSize::Wasm64) {
                     8
                 } else {
                     4