Use InstanceSigs in GND/DerivingVia-generated code (#17899)

Aside from making the generated code easier to read when
`-ddump-deriv` is enabled, this makes the error message in `T15073`
substantially simpler (see the updated `T15073` expected stderr).

Fixes #17899.

compiler/GHC/Hs/Utils.hs

@@ -725,9 +725,10 @@ signatures in order to kind-check. Here is an example from #14579:
 The derived Eq instance for Glurp (without any kind signatures) would be:
 
   instance Eq a => Eq (Glurp a) where
+    (==) :: Glurp a -> Glurp a -> Bool
     (==) = coerce @(Wat2 P  -> Wat2 P  -> Bool)
                   @(Glurp a -> Glurp a -> Bool)
-                  (==) :: Glurp a -> Glurp a -> Bool
+                  (==)
 
 (Where the visible type applications use types produced by typeToLHsType.)
 

compiler/typecheck/TcDeriv.hs

@@ -42,7 +42,6 @@ import TyCoPpr    ( pprTyVars )
 import GHC.Rename.Names  ( extendGlobalRdrEnvRn )
 import GHC.Rename.Binds
 import GHC.Rename.Env
-import GHC.Rename.Utils  ( bindLocalNamesFV )
 import GHC.Rename.Source ( addTcgDUs )
 import Avail
 
@@ -315,12 +314,11 @@ renameDeriv inst_infos bagBinds
                             , ib_pragmas = sigs
                             , ib_extensions = exts -- Only for type-checking
                             , ib_derived = sa } })
-        =  ASSERT( null sigs )
-           bindLocalNamesFV tyvars $
-           do { (rn_binds,_, fvs) <- rnMethodBinds False (is_cls_nm inst) [] binds []
+        =  do { (rn_binds, rn_sigs, fvs) <- rnMethodBinds False (is_cls_nm inst)
+                                                          tyvars binds sigs
               ; let binds' = InstBindings { ib_binds = rn_binds
                                           , ib_tyvars = tyvars
-                                          , ib_pragmas = []
+                                          , ib_pragmas = rn_sigs
                                           , ib_extensions = exts
                                           , ib_derived = sa }
               ; return (inst_info { iBinds = binds' }, fvs) }
@@ -1846,7 +1844,7 @@ genInst :: DerivSpec theta
 genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
                  , ds_tys = tys, ds_cls = clas, ds_loc = loc
                  , ds_standalone_wildcard = wildcard })
-  = do (meth_binds, deriv_stuff, unusedNames)
+  = do (meth_binds, meth_sigs, deriv_stuff, unusedNames)
          <- set_span_and_ctxt $
             genDerivStuff mechanism loc clas tys tvs
        let mk_inst_info theta = set_span_and_ctxt $ do
@@ -1858,7 +1856,7 @@ genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
                        , iBinds  = InstBindings
                                      { ib_binds = meth_binds
                                      , ib_tyvars = map Var.varName tvs
-                                     , ib_pragmas = []
+                                     , ib_pragmas = meth_sigs
                                      , ib_extensions = extensions
                                      , ib_derived = True } }
        return (mk_inst_info, deriv_stuff, unusedNames)
@@ -1866,9 +1864,14 @@ genInst spec@(DS { ds_tvs = tvs, ds_mechanism = mechanism
     extensions :: [LangExt.Extension]
     extensions
       | isDerivSpecNewtype mechanism || isDerivSpecVia mechanism
-        -- Both these flags are needed for higher-rank uses of coerce
-        -- See Note [Newtype-deriving instances] in TcGenDeriv
-      = [LangExt.ImpredicativeTypes, LangExt.RankNTypes]
+      = [
+          -- Both these flags are needed for higher-rank uses of coerce...
+          LangExt.ImpredicativeTypes, LangExt.RankNTypes
+          -- ...and this flag is needed to support the instance signatures
+          -- that bring type variables into scope.
+          -- See Note [Newtype-deriving instances] in TcGenDeriv
+        , LangExt.InstanceSigs
+        ]
       | otherwise
       = []
 
@@ -2035,7 +2038,7 @@ derivingThingFailWith newtype_deriving msg = do
 
 genDerivStuff :: DerivSpecMechanism -> SrcSpan -> Class
               -> [Type] -> [TyVar]
-              -> TcM (LHsBinds GhcPs, BagDerivStuff, [Name])
+              -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff, [Name])
 genDerivStuff mechanism loc clas inst_tys tyvars
   = case mechanism of
       -- See Note [Bindings for Generalised Newtype Deriving]
@@ -2045,7 +2048,8 @@ genDerivStuff mechanism loc clas inst_tys tyvars
       -- Try a stock deriver
       DerivSpecStock { dsm_stock_dit    = DerivInstTys{dit_rep_tc = rep_tc}
                      , dsm_stock_gen_fn = gen_fn }
-        -> gen_fn loc rep_tc inst_tys
+        -> do (binds, faminsts, field_names) <- gen_fn loc rep_tc inst_tys
+              pure (binds, [], faminsts, field_names)
 
       -- Try DeriveAnyClass
       DerivSpecAnyClass -> do
@@ -2059,7 +2063,7 @@ genDerivStuff mechanism loc clas inst_tys tyvars
                  , ppr "genDerivStuff: bad derived class" <+> ppr clas )
           mapM (tcATDefault loc mini_subst emptyNameSet)
                (classATItems clas)
-        return ( emptyBag -- No method bindings are needed...
+        return ( emptyBag, [] -- No method bindings are needed...
                , listToBag (map DerivFamInst (concat tyfam_insts))
                -- ...but we may need to generate binding for associated type
                -- family default instances.
@@ -2071,8 +2075,8 @@ genDerivStuff mechanism loc clas inst_tys tyvars
         -> gen_newtype_or_via via_ty
   where
     gen_newtype_or_via ty = do
-      (binds, faminsts) <- gen_Newtype_binds loc clas tyvars inst_tys ty
-      return (binds, faminsts, [])
+      (binds, sigs, faminsts) <- gen_Newtype_binds loc clas tyvars inst_tys ty
+      return (binds, sigs, faminsts, [])
 
 {-
 Note [Bindings for Generalised Newtype Deriving]

compiler/typecheck/TcEnv.hs

@@ -952,7 +952,8 @@ pprInstInfoDetails info
    = hang (pprInstanceHdr (iSpec info) <+> text "where")
         2 (details (iBinds info))
   where
-    details (InstBindings { ib_binds = b }) = pprLHsBinds b
+    details (InstBindings { ib_pragmas = p, ib_binds = b }) =
+      pprDeclList (pprLHsBindsForUser b p)
 
 simpleInstInfoClsTy :: InstInfo a -> (Class, Type)
 simpleInstInfoClsTy info = case instanceHead (iSpec info) of

compiler/typecheck/TcGenDeriv.hs

@@ -1610,9 +1610,10 @@ coercing from.  So from, say,
   newtype T x = MkT <rep-ty>
 
   instance C a <rep-ty> => C a (T x) where
-    op = coerce @ (a -> [<rep-ty>] -> c -> Int)
-                @ (a -> [T x]      -> c -> Int)
-                op :: forall c. a -> [T x] -> c -> Int
+    op :: forall c. a -> [T x] -> c -> Int
+    op = coerce @(a -> [<rep-ty>] -> c -> Int)
+                @(a -> [T x]      -> c -> Int)
+                op
 
 In addition to the type applications, we also have an explicit
 type signature on the entire RHS. This brings the method-bound variable
@@ -1632,16 +1633,17 @@ a polytype.  E.g.
    class C a where op :: a -> forall b. b -> b
    newtype T x = MkT <rep-ty>
    instance C <rep-ty> => C (T x) where
-     op = coerce @ (<rep-ty> -> forall b. b -> b)
-                 @ (T x      -> forall b. b -> b)
-                op :: T x -> forall b. b -> b
+     op :: T x -> forall b. b -> b
+     op = coerce @(<rep-ty> -> forall b. b -> b)
+                 @(T x      -> forall b. b -> b)
+                op
 
 The use of type applications is crucial here. If we had tried using only
 explicit type signatures, like so:
 
    instance C <rep-ty> => C (T x) where
+     op :: T x -> forall b. b -> b
      op = coerce (op :: <rep-ty> -> forall b. b -> b)
-                     :: T x      -> forall b. b -> b
 
 Then GHC will attempt to deeply skolemize the two type signatures, which will
 wreak havoc with the Coercible solver. Therefore, we instead use type
@@ -1721,23 +1723,26 @@ See Note [Instances in no-evidence implications] in TcInteract.
 But this isn't the death knell for combining QuantifiedConstraints with GND.
 On the contrary, if we generate GND bindings in a slightly different way, then
 we can avoid this situation altogether. Instead of applying `coerce` to two
-polymorphic types, we instead let an explicit type signature do the polymorphic
+polymorphic types, we instead let an instance signature do the polymorphic
 instantiation, and omit the `forall`s in the type applications.
 More concretely, we generate the following code instead:
 
   instance (C m, forall p q. Coercible p q => Coercible (m p) (m q)) =>
       C (T m) where
+    join :: forall a. T m (T m a) -> T m a
     join = coerce @(  m   (m a) ->   m a)
                   @(T m (T m a) -> T m a)
-                  join :: forall a. T m (T m a) -> T m a
+                  join
 
-Now the visible type arguments are both monotypes, so we need do any of this
-funny quantified constraint instantiation business.
+Now the visible type arguments are both monotypes, so we don't need any of this
+funny quantified constraint instantiation business. While this particular
+example no longer uses impredicative instantiation, we still need to enable
+ImpredicativeTypes to typecheck GND-generated code for class methods with
+higher-rank types. See Note [Newtype-deriving instances].
 
 You might think that that second @(T m (T m a) -> T m a) argument is redundant
-in the presence of the explicit `:: forall a. T m (T m a) -> T m a` type
-signature, but in fact leaving it off will break this example (from the
-T15290d test case):
+in the presence of the instance signature, but in fact leaving it off will
+break this example (from the T15290d test case):
 
   class C a where
     c :: Int -> forall b. b -> a
@@ -1745,14 +1750,15 @@ T15290d test case):
   instance C Int
 
   instance C Age where
+    c :: Int -> forall b. b -> Age
     c = coerce @(Int -> forall b. b -> Int)
-               c :: Int -> forall b. b -> Age
+               c
 
-That is because the explicit type signature deeply skolemizes the forall-bound
+That is because the instance signature deeply skolemizes the forall-bound
 `b`, which wreaks havoc with the `Coercible` solver. An additional visible type
 argument of @(Int -> forall b. b -> Age) is enough to prevent this.
 
-Be aware that the use of an explicit type signature doesn't /solve/ this
+Be aware that the use of an instance signature doesn't /solve/ this
 problem; it just makes it less likely to occur. For example, if a class has
 a truly higher-rank type like so:
 
@@ -1775,8 +1781,8 @@ ambiguous type variables. As one example, consider the following example
 A naïve attempt and generating a C T instance would be:
 
   instance C T where
+    f :: String
     f = coerce @String @String f
-          :: String
 
 This isn't going to typecheck, however, since GHC doesn't know what to
 instantiate the type variable `a` with in the call to `f` in the method body.
@@ -1784,8 +1790,8 @@ instantiate the type variable `a` with in the call to `f` in the method body.
 ambiguity here, we explicitly instantiate `a` like so:
 
   instance C T where
+    f :: String
     f = coerce @String @String (f @())
-          :: String
 
 All better now.
 -}
@@ -1797,32 +1803,58 @@ gen_Newtype_binds :: SrcSpan
                              -- newtype itself)
                   -> [Type]  -- instance head parameters (incl. newtype)
                   -> Type    -- the representation type
-                  -> TcM (LHsBinds GhcPs, BagDerivStuff)
+                  -> TcM (LHsBinds GhcPs, [LSig GhcPs], BagDerivStuff)
 -- See Note [Newtype-deriving instances]
 gen_Newtype_binds loc cls inst_tvs inst_tys rhs_ty
   = do let ats = classATs cls
+           (binds, sigs) = mapAndUnzip mk_bind_and_sig (classMethods cls)
        atf_insts <- ASSERT( all (not . isDataFamilyTyCon) ats )
                     mapM mk_atf_inst ats
-       return ( listToBag $ map mk_bind (classMethods cls)
+       return ( listToBag binds
+              , sigs
               , listToBag $ map DerivFamInst atf_insts )
   where
-    mk_bind :: Id -> LHsBind GhcPs
-    mk_bind meth_id
-      = mkRdrFunBind (L loc meth_RDR) [mkSimpleMatch
-                                          (mkPrefixFunRhs (L loc meth_RDR))
-                                          [] rhs_expr]
+    -- For each class method, generate its derived binding and instance
+    -- signature. Using the first example from
+    -- Note [Newtype-deriving instances]:
+    --
+    --   class C a b where
+    --     op :: forall c. a -> [b] -> c -> Int
+    --
+    --   newtype T x = MkT <rep-ty>
+    --
+    -- Then we would generate <derived-op-impl> below:
+    --
+    --   instance C a <rep-ty> => C a (T x) where
+    --     <derived-op-impl>
+    mk_bind_and_sig :: Id -> (LHsBind GhcPs, LSig GhcPs)
+    mk_bind_and_sig meth_id
+      = ( -- The derived binding, e.g.,
+          --
+          --   op = coerce @(a -> [<rep-ty>] -> c -> Int)
+          --               @(a -> [T x]      -> c -> Int)
+          --               op
+          mkRdrFunBind loc_meth_RDR [mkSimpleMatch
+                                        (mkPrefixFunRhs loc_meth_RDR)
+                                        [] rhs_expr]
+        , -- The derived instance signature, e.g.,
+          --
+          --   op :: forall c. a -> [T x] -> c -> Int
+          L loc $ ClassOpSig noExtField False [loc_meth_RDR]
+                $ mkLHsSigType $ typeToLHsType to_ty
+        )
       where
         Pair from_ty to_ty = mkCoerceClassMethEqn cls inst_tvs inst_tys rhs_ty meth_id
         (_, _, from_tau) = tcSplitSigmaTy from_ty
         (_, _, to_tau)   = tcSplitSigmaTy to_ty
 
         meth_RDR = getRdrName meth_id
+        loc_meth_RDR = L loc meth_RDR
 
         rhs_expr = nlHsVar (getRdrName coerceId)
                                       `nlHsAppType`     from_tau
                                       `nlHsAppType`     to_tau
                                       `nlHsApp`         meth_app
-                                      `nlExprWithTySig` to_ty
 
         -- The class method, applied to all of the class instance types
         -- (including the representation type) to avoid potential ambiguity.

testsuite/tests/deriving/should_compile/T14578.stderr

@@ -4,23 +4,27 @@ Derived class instances:
   instance (GHC.Base.Applicative f, GHC.Base.Applicative g,
             GHC.Base.Semigroup a) =>
            GHC.Base.Semigroup (T14578.Wat f g a) where
+    (GHC.Base.<>) ::
+      T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a
+    GHC.Base.sconcat ::
+      GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a
+    GHC.Base.stimes ::
+      forall (b :: TYPE GHC.Types.LiftedRep).
+      GHC.Real.Integral b => b -> T14578.Wat f g a -> T14578.Wat f g a
     (GHC.Base.<>)
       = GHC.Prim.coerce
           @(T14578.App (Data.Functor.Compose.Compose f g) a
             -> T14578.App (Data.Functor.Compose.Compose f g) a
                -> T14578.App (Data.Functor.Compose.Compose f g) a)
           @(T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a)
-          ((GHC.Base.<>)
-             @(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
-          T14578.Wat f g a -> T14578.Wat f g a -> T14578.Wat f g a
+          ((GHC.Base.<>) @(T14578.App (Data.Functor.Compose.Compose f g) a))
     GHC.Base.sconcat
       = GHC.Prim.coerce
           @(GHC.Base.NonEmpty (T14578.App (Data.Functor.Compose.Compose f g) a)
             -> T14578.App (Data.Functor.Compose.Compose f g) a)
           @(GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a)
           (GHC.Base.sconcat
-             @(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
-          GHC.Base.NonEmpty (T14578.Wat f g a) -> T14578.Wat f g a
+             @(T14578.App (Data.Functor.Compose.Compose f g) a))
     GHC.Base.stimes
       = GHC.Prim.coerce
           @(b
@@ -28,69 +32,72 @@ Derived class instances:
                -> T14578.App (Data.Functor.Compose.Compose f g) a)
           @(b -> T14578.Wat f g a -> T14578.Wat f g a)
           (GHC.Base.stimes
-             @(T14578.App (Data.Functor.Compose.Compose f g) a)) ::
-          forall (b :: TYPE GHC.Types.LiftedRep).
-          GHC.Real.Integral b => b -> T14578.Wat f g a -> T14578.Wat f g a
+             @(T14578.App (Data.Functor.Compose.Compose f g) a))
   
   instance GHC.Base.Functor f =>
            GHC.Base.Functor (T14578.App f) where
+    GHC.Base.fmap ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep).
+      (a -> b) -> T14578.App f a -> T14578.App f b
+    (GHC.Base.<$) ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep).
+      a -> T14578.App f b -> T14578.App f a
     GHC.Base.fmap
       = GHC.Prim.coerce
           @((a -> b) -> f a -> f b)
-          @((a -> b) -> T14578.App f a -> T14578.App f b)
-          (GHC.Base.fmap @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep).
-          (a -> b) -> T14578.App f a -> T14578.App f b
+          @((a -> b) -> T14578.App f a -> T14578.App f b) (GHC.Base.fmap @f)
     (GHC.Base.<$)
       = GHC.Prim.coerce
-          @(a -> f b -> f a)
-          @(a -> T14578.App f b -> T14578.App f a)
-          ((GHC.Base.<$) @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep).
-          a -> T14578.App f b -> T14578.App f a
+          @(a -> f b -> f a) @(a -> T14578.App f b -> T14578.App f a)
+          ((GHC.Base.<$) @f)
   
   instance GHC.Base.Applicative f =>
            GHC.Base.Applicative (T14578.App f) where
+    GHC.Base.pure ::
+      forall (a :: TYPE GHC.Types.LiftedRep). a -> T14578.App f a
+    (GHC.Base.<*>) ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep).
+      T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b
+    GHC.Base.liftA2 ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep)
+             (c :: TYPE GHC.Types.LiftedRep).
+      (a -> b -> c) -> T14578.App f a -> T14578.App f b -> T14578.App f c
+    (GHC.Base.*>) ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep).
+      T14578.App f a -> T14578.App f b -> T14578.App f b
+    (GHC.Base.<*) ::
+      forall (a :: TYPE GHC.Types.LiftedRep)
+             (b :: TYPE GHC.Types.LiftedRep).
+      T14578.App f a -> T14578.App f b -> T14578.App f a
     GHC.Base.pure
       = GHC.Prim.coerce
-          @(a -> f a) @(a -> T14578.App f a) (GHC.Base.pure @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep). a -> T14578.App f a
+          @(a -> f a) @(a -> T14578.App f a) (GHC.Base.pure @f)
     (GHC.Base.<*>)
       = GHC.Prim.coerce
           @(f (a -> b) -> f a -> f b)
           @(T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b)
-          ((GHC.Base.<*>) @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep).
-          T14578.App f (a -> b) -> T14578.App f a -> T14578.App f b
+          ((GHC.Base.<*>) @f)
     GHC.Base.liftA2
       = GHC.Prim.coerce
           @((a -> b -> c) -> f a -> f b -> f c)
           @((a -> b -> c)
             -> T14578.App f a -> T14578.App f b -> T14578.App f c)
-          (GHC.Base.liftA2 @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep)
-                 (c :: TYPE GHC.Types.LiftedRep).
-          (a -> b -> c) -> T14578.App f a -> T14578.App f b -> T14578.App f c
+          (GHC.Base.liftA2 @f)
     (GHC.Base.*>)
       = GHC.Prim.coerce
           @(f a -> f b -> f b)
           @(T14578.App f a -> T14578.App f b -> T14578.App f b)
-          ((GHC.Base.*>) @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep).
-          T14578.App f a -> T14578.App f b -> T14578.App f b
+          ((GHC.Base.*>) @f)
     (GHC.Base.<*)
       = GHC.Prim.coerce
           @(f a -> f b -> f a)
           @(T14578.App f a -> T14578.App f b -> T14578.App f a)
-          ((GHC.Base.<*) @f) ::
-          forall (a :: TYPE GHC.Types.LiftedRep)
-                 (b :: TYPE GHC.Types.LiftedRep).
-          T14578.App f a -> T14578.App f b -> T14578.App f a
+          ((GHC.Base.<*) @f)
   
 
 Derived type family instances:

testsuite/tests/deriving/should_compile/T14579.stderr

@@ -2,36 +2,40 @@
 ==================== Derived instances ====================
 Derived class instances:
   instance GHC.Classes.Eq a => GHC.Classes.Eq (T14579.Glurp a) where
+    (GHC.Classes.==) ::
+      T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
+    (GHC.Classes./=) ::
+      T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
     (GHC.Classes.==)
       = GHC.Prim.coerce
           @(T14579.Wat @a (Data.Proxy.Proxy @a)
             -> T14579.Wat @a (Data.Proxy.Proxy @a) -> GHC.Types.Bool)
           @(T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool)
-          ((GHC.Classes.==) @(T14579.Wat @a (Data.Proxy.Proxy @a))) ::
-          T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
+          ((GHC.Classes.==) @(T14579.Wat @a (Data.Proxy.Proxy @a)))
     (GHC.Classes./=)
       = GHC.Prim.coerce
           @(T14579.Wat @a (Data.Proxy.Proxy @a)
             -> T14579.Wat @a (Data.Proxy.Proxy @a) -> GHC.Types.Bool)
           @(T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool)
-          ((GHC.Classes./=) @(T14579.Wat @a (Data.Proxy.Proxy @a))) ::
-          T14579.Glurp a -> T14579.Glurp a -> GHC.Types.Bool
+          ((GHC.Classes./=) @(T14579.Wat @a (Data.Proxy.Proxy @a)))
   
   instance forall a (x :: Data.Proxy.Proxy a).
            GHC.Classes.Eq a =>
            GHC.Classes.Eq (T14579.Wat x) where
+    (GHC.Classes.==) ::
+      T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
+    (GHC.Classes./=) ::
+      T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
     (GHC.Classes.==)
       = GHC.Prim.coerce
           @(GHC.Maybe.Maybe a -> GHC.Maybe.Maybe a -> GHC.Types.Bool)
           @(T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool)
-          ((GHC.Classes.==) @(GHC.Maybe.Maybe a)) ::
-          T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
+          ((GHC.Classes.==) @(GHC.Maybe.Maybe a))
     (GHC.Classes./=)
       = GHC.Prim.coerce
           @(GHC.Maybe.Maybe a -> GHC.Maybe.Maybe a -> GHC.Types.Bool)
           @(T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool)
-          ((GHC.Classes./=) @(GHC.Maybe.Maybe a)) ::
-          T14579.Wat @a x -> T14579.Wat @a x -> GHC.Types.Bool
+          ((GHC.Classes./=) @(GHC.Maybe.Maybe a))
   
 
 Derived type family instances:

testsuite/tests/deriving/should_fail/T15073.stderr

@@ -2,20 +2,9 @@
 T15073.hs:8:12: error:
     • Illegal unboxed tuple type as function argument: (# Foo a #)
       Perhaps you intended to use UnboxedTuples
-    • In an expression type signature:
-        Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
-      In the expression:
-          GHC.Prim.coerce
-            @(a -> Unit# @GHC.Types.LiftedRep a)
-            @(Foo a -> Unit# @GHC.Types.LiftedRep (Foo a))
-            (p @a) ::
-            Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
-      In an equation for ‘p’:
-          p = GHC.Prim.coerce
-                @(a -> Unit# @GHC.Types.LiftedRep a)
-                @(Foo a -> Unit# @GHC.Types.LiftedRep (Foo a))
-                (p @a) ::
-                Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
+    • In the type signature:
+        p :: Foo a -> Unit# @GHC.Types.LiftedRep (Foo a)
       When typechecking the code for ‘p’
         in a derived instance for ‘P (Foo a)’:
         To see the code I am typechecking, use -ddump-deriv
+      In the instance declaration for ‘P (Foo a)’

testsuite/tests/deriving/should_fail/T4846.stderr

@@ -3,12 +3,9 @@ T4846.hs:29:1: error:
     • Couldn't match type ‘Bool’ with ‘BOOL’
         arising from a use of ‘GHC.Prim.coerce’
     • In the expression:
-          GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool) ::
-            Expr BOOL
+        GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool)
       In an equation for ‘mkExpr’:
-          mkExpr
-            = GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool) ::
-                Expr BOOL
+          mkExpr = GHC.Prim.coerce @(Expr Bool) @(Expr BOOL) (mkExpr @Bool)
       When typechecking the code for ‘mkExpr’
         in a derived instance for ‘B BOOL’:
         To see the code I am typechecking, use -ddump-deriv

testsuite/tests/deriving/should_fail/deriving-via-fail5.stderr

@@ -9,18 +9,14 @@ deriving-via-fail5.hs:8:1: error:
         the instance declaration
         at deriving-via-fail5.hs:(8,1)-(9,24)
     • In the expression:
-          GHC.Prim.coerce
-            @(Int -> Identity b -> ShowS)
-            @(Int -> Foo4 a -> ShowS)
-            (showsPrec @(Identity b)) ::
-            Int -> Foo4 a -> ShowS
+        GHC.Prim.coerce
+          @(Int -> Identity b -> ShowS) @(Int -> Foo4 a -> ShowS)
+          (showsPrec @(Identity b))
       In an equation for ‘showsPrec’:
           showsPrec
             = GHC.Prim.coerce
-                @(Int -> Identity b -> ShowS)
-                @(Int -> Foo4 a -> ShowS)
-                (showsPrec @(Identity b)) ::
-                Int -> Foo4 a -> ShowS
+                @(Int -> Identity b -> ShowS) @(Int -> Foo4 a -> ShowS)
+                (showsPrec @(Identity b))
       When typechecking the code for ‘showsPrec’
         in a derived instance for ‘Show (Foo4 a)’:
         To see the code I am typechecking, use -ddump-deriv
@@ -39,14 +35,12 @@ deriving-via-fail5.hs:8:1: error:
         the instance declaration
         at deriving-via-fail5.hs:(8,1)-(9,24)
     • In the expression:
-          GHC.Prim.coerce
-            @(Identity b -> String) @(Foo4 a -> String) (show @(Identity b)) ::
-            Foo4 a -> String
+        GHC.Prim.coerce
+          @(Identity b -> String) @(Foo4 a -> String) (show @(Identity b))
       In an equation for ‘show’:
           show
             = GHC.Prim.coerce
-                @(Identity b -> String) @(Foo4 a -> String) (show @(Identity b)) ::
-                Foo4 a -> String
+                @(Identity b -> String) @(Foo4 a -> String) (show @(Identity b))
       When typechecking the code for ‘show’
         in a derived instance for ‘Show (Foo4 a)’:
         To see the code I am typechecking, use -ddump-deriv
@@ -64,18 +58,14 @@ deriving-via-fail5.hs:8:1: error:
         the instance declaration
         at deriving-via-fail5.hs:(8,1)-(9,24)
     • In the expression:
-          GHC.Prim.coerce
-            @([] (Identity b) -> ShowS)
-            @([] (Foo4 a) -> ShowS)
-            (showList @(Identity b)) ::
-            [] (Foo4 a) -> ShowS
+        GHC.Prim.coerce
+          @([] (Identity b) -> ShowS) @([] (Foo4 a) -> ShowS)
+          (showList @(Identity b))
       In an equation for ‘showList’:
           showList
             = GHC.Prim.coerce
-                @([] (Identity b) -> ShowS)
-                @([] (Foo4 a) -> ShowS)
-                (showList @(Identity b)) ::
-                [] (Foo4 a) -> ShowS
+                @([] (Identity b) -> ShowS) @([] (Foo4 a) -> ShowS)
+                (showList @(Identity b))
       When typechecking the code for ‘showList’
         in a derived instance for ‘Show (Foo4 a)’:
         To see the code I am typechecking, use -ddump-deriv