1 files changed, 72 insertions, 43 deletions
diff --git a/third_party/rust/uniffi_bindgen/src/bindings/kotlin/gen_kotlin/compounds.rs b/third_party/rust/uniffi_bindgen/src/bindings/kotlin/gen_kotlin/compounds.rs
index 4329f32f4c..8d075bbedb 100644
--- a/third_party/rust/uniffi_bindgen/src/bindings/kotlin/gen_kotlin/compounds.rs
+++ b/third_party/rust/uniffi_bindgen/src/bindings/kotlin/gen_kotlin/compounds.rs
@@ -5,55 +5,81 @@
 use super::{AsCodeType, CodeType};
 use crate::backend::{Literal, Type};
 use crate::ComponentInterface;
-use paste::paste;
 
-fn render_literal(literal: &Literal, inner: &Type, ci: &ComponentInterface) -> String {
-    match literal {
-        Literal::Null => "null".into(),
-        Literal::EmptySequence => "listOf()".into(),
-        Literal::EmptyMap => "mapOf()".into(),
+#[derive(Debug)]
+pub struct OptionalCodeType {
+    inner: Type,
+}
 
-        // For optionals
-        _ => super::KotlinCodeOracle.find(inner).literal(literal, ci),
+impl OptionalCodeType {
+    pub fn new(inner: Type) -> Self {
+        Self { inner }
+    }
+    fn inner(&self) -> &Type {
+        &self.inner
     }
 }
 
-macro_rules! impl_code_type_for_compound {
-     ($T:ty, $type_label_pattern:literal, $canonical_name_pattern: literal) => {
-        paste! {
-            #[derive(Debug)]
-            pub struct $T {
-                inner: Type,
-            }
-
-            impl $T {
-                pub fn new(inner: Type) -> Self {
-                    Self { inner }
-                }
-                fn inner(&self) -> &Type {
-                    &self.inner
-                }
-            }
-
-            impl CodeType for $T  {
-                fn type_label(&self, ci: &ComponentInterface) -> String {
-                    format!($type_label_pattern, super::KotlinCodeOracle.find(self.inner()).type_label(ci))
-                }
-
-                fn canonical_name(&self) -> String {
-                    format!($canonical_name_pattern, super::KotlinCodeOracle.find(self.inner()).canonical_name())
-                }
-
-                fn literal(&self, literal: &Literal, ci: &ComponentInterface) -> String {
-                    render_literal(literal, self.inner(), ci)
-                }
-            }
+impl CodeType for OptionalCodeType {
+    fn type_label(&self, ci: &ComponentInterface) -> String {
+        format!(
+            "{}?",
+            super::KotlinCodeOracle.find(self.inner()).type_label(ci)
+        )
+    }
+
+    fn canonical_name(&self) -> String {
+        format!(
+            "Optional{}",
+            super::KotlinCodeOracle.find(self.inner()).canonical_name()
+        )
+    }
+
+    fn literal(&self, literal: &Literal, ci: &ComponentInterface) -> String {
+        match literal {
+            Literal::None => "null".into(),
+            Literal::Some { inner } => super::KotlinCodeOracle.find(&self.inner).literal(inner, ci),
+            _ => panic!("Invalid literal for Optional type: {literal:?}"),
         }
     }
- }
+}
 
-impl_code_type_for_compound!(OptionalCodeType, "{}?", "Optional{}");
-impl_code_type_for_compound!(SequenceCodeType, "List<{}>", "Sequence{}");
+#[derive(Debug)]
+pub struct SequenceCodeType {
+    inner: Type,
+}
+
+impl SequenceCodeType {
+    pub fn new(inner: Type) -> Self {
+        Self { inner }
+    }
+    fn inner(&self) -> &Type {
+        &self.inner
+    }
+}
+
+impl CodeType for SequenceCodeType {
+    fn type_label(&self, ci: &ComponentInterface) -> String {
+        format!(
+            "List<{}>",
+            super::KotlinCodeOracle.find(self.inner()).type_label(ci)
+        )
+    }
+
+    fn canonical_name(&self) -> String {
+        format!(
+            "Sequence{}",
+            super::KotlinCodeOracle.find(self.inner()).canonical_name()
+        )
+    }
+
+    fn literal(&self, literal: &Literal, _ci: &ComponentInterface) -> String {
+        match literal {
+            Literal::EmptySequence => "listOf()".into(),
+            _ => panic!("Invalid literal for List type: {literal:?}"),
+        }
+    }
+}
 
 #[derive(Debug)]
 pub struct MapCodeType {
@@ -92,7 +118,10 @@ impl CodeType for MapCodeType {
         )
     }
 
-    fn literal(&self, literal: &Literal, ci: &ComponentInterface) -> String {
-        render_literal(literal, &self.value, ci)
+    fn literal(&self, literal: &Literal, _ci: &ComponentInterface) -> String {
+        match literal {
+            Literal::EmptyMap => "mapOf()".into(),
+            _ => panic!("Invalid literal for Map type: {literal:?}"),
+        }
     }
 }