Propagate 'Codable' bounds through MoatData tyvars

Author: tadfisher

.golden/kotlinGenericNewtypeSpec/golden

@@ -0,0 +1,3 @@
+@Parcelize
+@Serializable
+value class LTree<A : Parcelable>(val value: List<A>) : Parcelable

.golden/kotlinGenericStructSpec/golden

@@ -0,0 +1,10 @@
+/**
+ * Non-empty, possibly infinite, multi-way trees; also known as *rose trees*.
+ *
+ * @param rootLabel label value
+ * @param subForest zero or more child trees
+ */
+data class Tree<A : Parcelable>(
+    val rootLabel: A,
+    val subForest: List<Tree<A>>,
+) : Parcelable

.golden/swiftGenericNewtypeSpec/golden

@@ -0,0 +1,4 @@
+struct LTree<A: Codable>: CaseIterable, Hashable, Codable {
+    typealias LTreeTag = Tagged<LTree, [A]>
+    let value: LTreeTag
+}

.golden/swiftGenericStructSpec/golden

@@ -0,0 +1,7 @@
+/// Non-empty, possibly infinite, multi-way trees; also known as *rose trees*.
+struct Tree<A: Codable>: Codable {
+    /// label value
+    var rootLabel: A
+    /// zero or more child trees
+    var subForest: [Tree<A>]
+}

.golden/swiftMultipleTypeVariableSpec/golden

@@ -1,4 +1,4 @@
-struct Data<A, B>: CaseIterable, Hashable, Codable {
+struct Data<A: Codable, B: Codable>: CaseIterable, Hashable, Codable {
     var field0: A
     var field1: B
 }

.golden/swiftTypeVariableSpec/golden

@@ -1,3 +1,3 @@
-struct Data<A>: CaseIterable, Hashable, Codable {
+struct Data<A: Codable>: CaseIterable, Hashable, Codable {
     var field0: A
 }

moat.cabal

@@ -83,6 +83,8 @@ test-suite spec
       DuplicateRecordFieldSpec
       EnumValueClassDocSpec
       EnumValueClassSpec
+      GenericNewtypeSpec
+      GenericStructSpec
       MultipleTypeVariableSpec
       StrictEnumsSpec
       StrictFieldsSpec

src/Moat/Pretty/Swift.hs

@@ -28,7 +28,7 @@ prettySwiftDataWith indent = \case
   MoatEnum {..} ->
     prettyTypeDoc "" enumDoc []
       ++ "enum "
-      ++ prettyMoatTypeHeader enumName enumTyVars
+      ++ prettyMoatTypeHeader enumName (addTyVarBounds enumTyVars enumProtocols)
       ++ prettyRawValueAndProtocols enumRawValue enumProtocols
       ++ " {"
       ++ newlineNonEmpty enumCases
@@ -41,7 +41,7 @@ prettySwiftDataWith indent = \case
   MoatStruct {..} ->
     prettyTypeDoc "" structDoc []
       ++ "struct "
-      ++ prettyMoatTypeHeader structName structTyVars
+      ++ prettyMoatTypeHeader structName (addTyVarBounds structTyVars structProtocols)
       ++ prettyRawValueAndProtocols Nothing structProtocols
       ++ " {"
       ++ newlineNonEmpty structFields
@@ -54,13 +54,13 @@ prettySwiftDataWith indent = \case
   MoatAlias {..} ->
     prettyTypeDoc "" aliasDoc []
       ++ "typealias "
-      ++ prettyMoatTypeHeader aliasName aliasTyVars
+      ++ prettyMoatTypeHeader aliasName (addTyVarBounds aliasTyVars [])
       ++ " = "
       ++ prettyMoatType aliasTyp
   MoatNewtype {..} ->
     prettyTypeDoc "" newtypeDoc []
       ++ "struct "
-      ++ prettyMoatTypeHeader newtypeName newtypeTyVars
+      ++ prettyMoatTypeHeader newtypeName (addTyVarBounds newtypeTyVars newtypeProtocols)
       ++ prettyRawValueAndProtocols Nothing newtypeProtocols
       ++ " {\n"
       ++ indents
@@ -268,3 +268,8 @@ prettyPrivateTypes indents = go
 onLast :: (a -> a) -> [a] -> [a]
 onLast _ [] = []
 onLast f (x : xs) = x : map f xs
+
+addTyVarBounds :: [String] -> [Protocol] -> [String]
+addTyVarBounds tyVars protos
+  | Codable `elem` protos = map (++ ": Codable") tyVars
+  | otherwise = tyVars

test/GenericNewtypeSpec.hs

@@ -0,0 +1,32 @@
+{-# LANGUAGE DerivingStrategies #-}
+
+module GenericNewtypeSpec where
+
+import Common
+import Data.List.NonEmpty (NonEmpty)
+import Moat
+import Test.Hspec
+import Test.Hspec.Golden
+import Prelude
+
+newtype LTree a = LTree (NonEmpty a)
+  deriving stock (Show, Eq)
+
+mobileGenWith
+  ( defaultOptions
+      { dataAnnotations = [Parcelize, Serializable]
+      , dataInterfaces = [Parcelable]
+      , dataProtocols = [OtherProtocol "CaseIterable", Hashable, Codable]
+      , dataRawValue = Just Str
+      }
+  )
+  ''LTree
+
+spec :: Spec
+spec =
+  describe "stays golden" $ do
+    let moduleName = "GenericNewtypeSpec"
+    it "swift" $
+      defaultGolden ("swift" <> moduleName) (showSwift @(LTree _))
+    it "kotlin" $
+      defaultGolden ("kotlin" <> moduleName) (showKotlin @(LTree _))

test/GenericStructSpec.hs

@@ -0,0 +1,27 @@
+{-# OPTIONS_GHC -Wno-orphans #-}
+
+module GenericStructSpec where
+
+import Common
+import Data.Tree (Tree)
+import Moat
+import Test.Hspec
+import Test.Hspec.Golden
+import Prelude
+
+mobileGenWith
+  ( defaultOptions
+      { dataInterfaces = [Parcelable]
+      , dataProtocols = [Codable]
+      }
+  )
+  ''Tree
+
+spec :: Spec
+spec =
+  describe "stays golden" $ do
+    let moduleName = "GenericStructSpec"
+    it "swift" $
+      defaultGolden ("swift" <> moduleName) (showSwift @(Tree _))
+    it "kotlin" $
+      defaultGolden ("kotlin" <> moduleName) (showKotlin @(Tree _))