Refactor derived Generic instances to reduce allocations

Previously, derived implementations of `to`/`from` in `Generic`
instances were wastefully putting extra `M1`s in every case, which led
to an O(n) increase in the number of coercions, resulting in a slowdown
during the typechecker phase.

This factors out the common `M1` in every case of a `to`/`from`
definition so that the typechecker has far fewer coercions to deal with.
For a datatype with 300 constructors, this change has been observed to
save almost 3 seconds of compilation time.

This is one step towards coming up with a solution for #5642.

Test Plan: ./validate

Reviewers: hvr, austin, simonpj, bgamari

Reviewed By: bgamari

Subscribers: basvandijk, carter, thomie, osa1

Differential Revision: https://phabricator.haskell.org/D2304

GHC Trac Issues: #5642

4 files changed, 381 insertions, 343 deletions

diff --git a/testsuite/tests/generics/GenDerivOutput.stderr b/testsuite/tests/generics/GenDerivOutput.stderr
index de11f431e9..2226783029 100644
--- a/testsuite/tests/generics/GenDerivOutput.stderr
+++ b/testsuite/tests/generics/GenDerivOutput.stderr
@@ -2,92 +2,96 @@
 ==================== Derived instances ====================
 Derived instances:
   instance GHC.Generics.Generic (GenDerivOutput.List a) where
-    GHC.Generics.from GenDerivOutput.Nil
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (GenDerivOutput.Cons g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = GenDerivOutput.Nil
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = GenDerivOutput.Cons g1 g2
-
+          (case x of {
+             GenDerivOutput.Nil
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             GenDerivOutput.Cons g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> GenDerivOutput.Nil
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> GenDerivOutput.Cons g1 g2 }
+  
   instance GHC.Generics.Generic1 GenDerivOutput.List where
-    GHC.Generics.from1 GenDerivOutput.Nil
-      = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (GenDerivOutput.Cons g1 g2)
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = GenDerivOutput.Nil
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = GenDerivOutput.Cons
-          (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             GenDerivOutput.Nil
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             GenDerivOutput.Cons g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> GenDerivOutput.Nil
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> GenDerivOutput.Cons
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
   instance GHC.Base.Functor GenDerivOutput.List where
     GHC.Base.fmap f GenDerivOutput.Nil = GenDerivOutput.Nil
     GHC.Base.fmap f (GenDerivOutput.Cons a1 a2)
       = GenDerivOutput.Cons (f a1) (GHC.Base.fmap f a2)
-
+  
   instance GHC.Generics.Generic (GenDerivOutput.Rose a) where
-    GHC.Generics.from GenDerivOutput.Empty
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (GenDerivOutput.Rose g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = GenDerivOutput.Empty
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = GenDerivOutput.Rose g1 g2
-
+          (case x of {
+             GenDerivOutput.Empty
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             GenDerivOutput.Rose g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> GenDerivOutput.Empty
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> GenDerivOutput.Rose g1 g2 }
+  
   instance GHC.Generics.Generic1 GenDerivOutput.Rose where
-    GHC.Generics.from1 GenDerivOutput.Empty
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (GenDerivOutput.Rose g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1
-                      ((GHC.Base..)
-                         GHC.Generics.Comp1 (GHC.Base.fmap GHC.Generics.Rec1) g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = GenDerivOutput.Empty
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = GenDerivOutput.Rose
-          (GHC.Generics.unPar1 g1)
-          ((GHC.Base..)
-             (GHC.Base.fmap GHC.Generics.unRec1) GHC.Generics.unComp1 g2)
-
+          (case x of {
+             GenDerivOutput.Empty
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             GenDerivOutput.Rose g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1
+                             ((GHC.Base..)
+                                GHC.Generics.Comp1 (GHC.Base.fmap GHC.Generics.Rec1) g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> GenDerivOutput.Empty
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> GenDerivOutput.Rose
+                 (GHC.Generics.unPar1 g1)
+                 ((GHC.Base..)
+                    (GHC.Base.fmap GHC.Generics.unRec1) GHC.Generics.unComp1 g2) }
+  
 
 GHC.Generics representation types:
   type GHC.Generics.Rep (GenDerivOutput.List a) = GHC.Generics.D1
diff --git a/testsuite/tests/generics/GenDerivOutput1_0.stderr b/testsuite/tests/generics/GenDerivOutput1_0.stderr
index 0f4df6275a..cc12b64a39 100644
--- a/testsuite/tests/generics/GenDerivOutput1_0.stderr
+++ b/testsuite/tests/generics/GenDerivOutput1_0.stderr
@@ -2,25 +2,26 @@
 ==================== Derived instances ====================
 Derived instances:
   instance GHC.Generics.Generic1 GenDerivOutput1_0.List where
-    GHC.Generics.from1 GenDerivOutput1_0.Nil
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (GenDerivOutput1_0.Cons g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = GenDerivOutput1_0.Nil
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = GenDerivOutput1_0.Cons
-          (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             GenDerivOutput1_0.Nil
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             GenDerivOutput1_0.Cons g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> GenDerivOutput1_0.Nil
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> GenDerivOutput1_0.Cons
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
 
 GHC.Generics representation types:
   type GHC.Generics.Rep1 GenDerivOutput1_0.List = GHC.Generics.D1
diff --git a/testsuite/tests/generics/GenDerivOutput1_1.stderr b/testsuite/tests/generics/GenDerivOutput1_1.stderr
index d76d6bb593..53dbda1d62 100644
--- a/testsuite/tests/generics/GenDerivOutput1_1.stderr
+++ b/testsuite/tests/generics/GenDerivOutput1_1.stderr
@@ -2,157 +2,165 @@
 ==================== Derived instances ====================
 Derived instances:
   instance GHC.Generics.Generic1 CanDoRep1_1.Dd where
-    GHC.Generics.from1 CanDoRep1_1.D0d
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (CanDoRep1_1.D1d g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0d
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = CanDoRep1_1.D1d (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             CanDoRep1_1.D0d
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1d g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0d
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> CanDoRep1_1.D1d
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
   instance GHC.Generics.Generic (CanDoRep1_1.Dd a) where
-    GHC.Generics.from CanDoRep1_1.D0d
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (CanDoRep1_1.D1d g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0d
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = CanDoRep1_1.D1d g1 g2
-
+          (case x of {
+             CanDoRep1_1.D0d
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1d g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0d
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> CanDoRep1_1.D1d g1 g2 }
+  
   instance GHC.Generics.Generic (CanDoRep1_1.Dc a) where
-    GHC.Generics.from CanDoRep1_1.D0c
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (CanDoRep1_1.D1c g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0c
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = CanDoRep1_1.D1c g1 g2
-
+          (case x of {
+             CanDoRep1_1.D0c
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1c g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0c
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> CanDoRep1_1.D1c g1 g2 }
+  
   instance GHC.Generics.Generic1 CanDoRep1_1.Db where
-    GHC.Generics.from1 CanDoRep1_1.D0b
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (CanDoRep1_1.D1b g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0b
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = CanDoRep1_1.D1b (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             CanDoRep1_1.D0b
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1b g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0b
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> CanDoRep1_1.D1b
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
   instance GHC.Generics.Generic (CanDoRep1_1.Da a) where
-    GHC.Generics.from CanDoRep1_1.D0
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (CanDoRep1_1.D1 g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = CanDoRep1_1.D1 g1 g2
-
+          (case x of {
+             CanDoRep1_1.D0 -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1 g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1) -> CanDoRep1_1.D0
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> CanDoRep1_1.D1 g1 g2 }
+  
   instance GHC.Generics.Generic1 CanDoRep1_1.Da where
-    GHC.Generics.from1 CanDoRep1_1.D0
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (CanDoRep1_1.D1 g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = CanDoRep1_1.D1 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             CanDoRep1_1.D0 -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1 g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1) -> CanDoRep1_1.D0
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> CanDoRep1_1.D1
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
   instance GHC.Generics.Generic (CanDoRep1_1.Db a) where
-    GHC.Generics.from CanDoRep1_1.D0b
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from (CanDoRep1_1.D1b g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0b
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = CanDoRep1_1.D1b g1 g2
-
+          (case x of {
+             CanDoRep1_1.D0b
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1b g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0b
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> CanDoRep1_1.D1b g1 g2 }
+  
   instance GHC.Generics.Generic1 CanDoRep1_1.Dc where
-    GHC.Generics.from1 CanDoRep1_1.D0c
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1))
-    GHC.Generics.from1 (CanDoRep1_1.D1c g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Par1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)))
-      = CanDoRep1_1.D0c
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = CanDoRep1_1.D1c (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2)
-
+          (case x of {
+             CanDoRep1_1.D0c
+               -> GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+             CanDoRep1_1.D1c g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Par1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 GHC.Generics.U1)
+            -> CanDoRep1_1.D0c
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> CanDoRep1_1.D1c
+                 (GHC.Generics.unPar1 g1) (GHC.Generics.unRec1 g2) }
+  
 
 GHC.Generics representation types:
   type GHC.Generics.Rep1 CanDoRep1_1.Dd = GHC.Generics.D1
diff --git a/testsuite/tests/generics/T10604/T10604_deriving.stderr b/testsuite/tests/generics/T10604/T10604_deriving.stderr
index cecb2ce308..cbaba8dbbe 100644
--- a/testsuite/tests/generics/T10604/T10604_deriving.stderr
+++ b/testsuite/tests/generics/T10604/T10604_deriving.stderr
@@ -2,162 +2,187 @@
 ==================== Derived instances ====================
 Derived instances:
   instance GHC.Generics.Generic (T10604_deriving.Empty a) where
-    GHC.Generics.from _
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Err.error
-             "No generic representation for empty datatype Empty")
-    GHC.Generics.to (GHC.Generics.M1 _)
-      = GHC.Err.error "No values for empty datatype Empty"
+          (case x of {
+             _ -> GHC.Err.error
+                    "No generic representation for empty datatype Empty" })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          _ -> GHC.Err.error "No values for empty datatype Empty" }
   
   instance GHC.Generics.Generic1
              GHC.Types.Bool T10604_deriving.Empty where
-    GHC.Generics.from1 _
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Err.error
-             "No generic representation for empty datatype Empty")
-    GHC.Generics.to1 (GHC.Generics.M1 _)
-      = GHC.Err.error "No values for empty datatype Empty"
+          (case x of {
+             _ -> GHC.Err.error
+                    "No generic representation for empty datatype Empty" })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          _ -> GHC.Err.error "No values for empty datatype Empty" }
   
   instance GHC.Base.Functor (T10604_deriving.Proxy *) where
     GHC.Base.fmap f T10604_deriving.Proxy = T10604_deriving.Proxy
   
   instance forall k (a :: k).
            GHC.Generics.Generic (T10604_deriving.Proxy k a) where
-    GHC.Generics.from T10604_deriving.Proxy
-      = GHC.Generics.M1 (GHC.Generics.M1 GHC.Generics.U1)
-    GHC.Generics.to (GHC.Generics.M1 (GHC.Generics.M1 GHC.Generics.U1))
-      = T10604_deriving.Proxy
+    GHC.Generics.from x
+      = GHC.Generics.M1
+          (case x of {
+             T10604_deriving.Proxy -> GHC.Generics.M1 GHC.Generics.U1 })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 GHC.Generics.U1 -> T10604_deriving.Proxy }
   
   instance GHC.Generics.Generic1 k (T10604_deriving.Proxy k) where
-    GHC.Generics.from1 T10604_deriving.Proxy
-      = GHC.Generics.M1 (GHC.Generics.M1 GHC.Generics.U1)
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.M1 GHC.Generics.U1))
-      = T10604_deriving.Proxy
+    GHC.Generics.from1 x
+      = GHC.Generics.M1
+          (case x of {
+             T10604_deriving.Proxy -> GHC.Generics.M1 GHC.Generics.U1 })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 GHC.Generics.U1 -> T10604_deriving.Proxy }
   
   instance GHC.Generics.Generic (T10604_deriving.Wrap a) where
-    GHC.Generics.from (T10604_deriving.Wrap g1)
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))))
-      = T10604_deriving.Wrap g1
+          (case x of {
+             T10604_deriving.Wrap g1
+               -> GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))
+            -> T10604_deriving.Wrap g1 }
   
   instance GHC.Generics.Generic1
              (GHC.Types.* -> GHC.Types.*) T10604_deriving.Wrap where
-    GHC.Generics.from1 (T10604_deriving.Wrap g1)
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.Rec1 g1)))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.M1 g1)))
-      = T10604_deriving.Wrap (GHC.Generics.unRec1 g1)
+          (case x of {
+             T10604_deriving.Wrap g1
+               -> GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.Rec1 g1)) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 (GHC.Generics.M1 g1)
+            -> T10604_deriving.Wrap (GHC.Generics.unRec1 g1) }
   
   instance forall k (a :: k -> GHC.Types.*).
            GHC.Generics.Generic (T10604_deriving.Wrap2 k a) where
-    GHC.Generics.from (T10604_deriving.Wrap2 g1)
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))))
-      = T10604_deriving.Wrap2 g1
+          (case x of {
+             T10604_deriving.Wrap2 g1
+               -> GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))
+            -> T10604_deriving.Wrap2 g1 }
   
   instance GHC.Generics.Generic1
              (k -> GHC.Types.*) (T10604_deriving.Wrap2 k) where
-    GHC.Generics.from1 (T10604_deriving.Wrap2 g1)
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.M1
-             (GHC.Generics.M1
-                ((GHC.Base..)
-                   GHC.Generics.Comp1 (GHC.Base.fmap GHC.Generics.Rec1) g1)))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.M1 g1)))
-      = T10604_deriving.Wrap2
-          ((GHC.Base..)
-             (GHC.Base.fmap GHC.Generics.unRec1) GHC.Generics.unComp1 g1)
+          (case x of {
+             T10604_deriving.Wrap2 g1
+               -> GHC.Generics.M1
+                    (GHC.Generics.M1
+                       ((GHC.Base..)
+                          GHC.Generics.Comp1 (GHC.Base.fmap GHC.Generics.Rec1) g1)) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.M1 (GHC.Generics.M1 g1)
+            -> T10604_deriving.Wrap2
+                 ((GHC.Base..)
+                    (GHC.Base.fmap GHC.Generics.unRec1) GHC.Generics.unComp1 g1) }
   
   instance forall k (a :: k).
            GHC.Generics.Generic (T10604_deriving.SumOfProducts k a) where
-    GHC.Generics.from (T10604_deriving.Prod1 g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.L1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.from (T10604_deriving.Prod2 g1 g2)
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.K1 g2)))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = T10604_deriving.Prod1 g1 g2
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
-                                                                             (GHC.Generics.M1 (GHC.Generics.K1 g2))))))
-      = T10604_deriving.Prod2 g1 g2
+          (case x of {
+             T10604_deriving.Prod1 g1 g2
+               -> GHC.Generics.L1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+             T10604_deriving.Prod2 g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.K1 g2)))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> T10604_deriving.Prod1 g1 g2
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 (GHC.Generics.K1 g1))
+                                                               (GHC.Generics.M1 (GHC.Generics.K1 g2))))
+            -> T10604_deriving.Prod2 g1 g2 }
   
   instance GHC.Generics.Generic1
              k (T10604_deriving.SumOfProducts k) where
-    GHC.Generics.from1 (T10604_deriving.Prod1 g1 g2)
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.L1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.from1 (T10604_deriving.Prod2 g1 g2)
-      = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1
-                ((GHC.Generics.:*:)
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g1))
-                   (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = T10604_deriving.Prod1
-          (GHC.Generics.unRec1 g1) (GHC.Generics.unRec1 g2)
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
-                                                                             (GHC.Generics.M1 g2)))))
-      = T10604_deriving.Prod2
-          (GHC.Generics.unRec1 g1) (GHC.Generics.unRec1 g2)
+          (case x of {
+             T10604_deriving.Prod1 g1 g2
+               -> GHC.Generics.L1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2))))
+             T10604_deriving.Prod2 g1 g2
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1
+                       ((GHC.Generics.:*:)
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g1))
+                          (GHC.Generics.M1 (GHC.Generics.Rec1 g2)))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> T10604_deriving.Prod1
+                 (GHC.Generics.unRec1 g1) (GHC.Generics.unRec1 g2)
+          GHC.Generics.R1 (GHC.Generics.M1 ((GHC.Generics.:*:) (GHC.Generics.M1 g1)
+                                                               (GHC.Generics.M1 g2)))
+            -> T10604_deriving.Prod2
+                 (GHC.Generics.unRec1 g1) (GHC.Generics.unRec1 g2) }
   
   instance GHC.Generics.Generic (T10604_deriving.Starify a) where
-    GHC.Generics.from (T10604_deriving.Starify1 g1)
-      = GHC.Generics.M1
-          (GHC.Generics.L1
-             (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))))
-    GHC.Generics.from (T10604_deriving.Starify2 g1)
+    GHC.Generics.from x
       = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))))
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))))
-      = T10604_deriving.Starify1 g1
-    GHC.Generics.to
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))))
-      = T10604_deriving.Starify2 g1
+          (case x of {
+             T10604_deriving.Starify1 g1
+               -> GHC.Generics.L1
+                    (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))
+             T10604_deriving.Starify2 g1
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))) })
+    GHC.Generics.to (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))
+            -> T10604_deriving.Starify1 g1
+          GHC.Generics.R1 (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1)))
+            -> T10604_deriving.Starify2 g1 }
   
   instance GHC.Generics.Generic1 * T10604_deriving.Starify where
-    GHC.Generics.from1 (T10604_deriving.Starify1 g1)
-      = GHC.Generics.M1
-          (GHC.Generics.L1
-             (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.Par1 g1))))
-    GHC.Generics.from1 (T10604_deriving.Starify2 g1)
+    GHC.Generics.from1 x
       = GHC.Generics.M1
-          (GHC.Generics.R1
-             (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))))
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.L1 (GHC.Generics.M1 (GHC.Generics.M1 g1))))
-      = T10604_deriving.Starify1 (GHC.Generics.unPar1 g1)
-    GHC.Generics.to1
-      (GHC.Generics.M1 (GHC.Generics.R1 (GHC.Generics.M1 (GHC.Generics.M1 g1))))
-      = T10604_deriving.Starify2 (GHC.Generics.unK1 g1)
+          (case x of {
+             T10604_deriving.Starify1 g1
+               -> GHC.Generics.L1
+                    (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.Par1 g1)))
+             T10604_deriving.Starify2 g1
+               -> GHC.Generics.R1
+                    (GHC.Generics.M1 (GHC.Generics.M1 (GHC.Generics.K1 g1))) })
+    GHC.Generics.to1 (GHC.Generics.M1 x)
+      = case x of {
+          GHC.Generics.L1 (GHC.Generics.M1 (GHC.Generics.M1 g1))
+            -> T10604_deriving.Starify1 (GHC.Generics.unPar1 g1)
+          GHC.Generics.R1 (GHC.Generics.M1 (GHC.Generics.M1 g1))
+            -> T10604_deriving.Starify2 (GHC.Generics.unK1 g1) }
   
 
 GHC.Generics representation types: