instance Outputable SimplPhase where

   ppr (SimplPhase p) = ppr p

 -- | Is this activation active in this simplifier phase?

 --

               False -> parens $ sep [ppr co, dcolon <+> co_type]

     where

       co_type = sdocOption sdocSuppressCoercionTypes $ \case

           False -> ppr (coercionType co)

 ppr_id_occ :: (SDoc -> SDoc) -> Id -> SDoc

               <+> text "may fail for the following constructors:")

            2

            (hsep $ punctuate comma $

   diagnosticReason = \case

     DsUnknownMessage m          -> diagnosticReason m

 -- Print a single clause (for redundant/with-inaccessible-rhs)

 pprEqn :: HsMatchContextRn -> SDoc -> String -> SDoc

 pprEqn ctx q txt = pprContext True ctx (text txt) $ \f ->

 pprContext :: Bool -> HsMatchContextRn -> SDoc -> ((SDoc -> SDoc) -> SDoc) -> SDoc

 pprContext singular kind msg rest_of_msg_fun

 dots :: Int -> [a] -> SDoc

 dots maxPatterns qs

     | otherwise                      = empty

   = var <+> text "is not one of" <+> format_alts alts

   where

     format_alts = braces . fsep . punctuate comma . shorten . map ppr_alt

     shorten xs                = xs

     ppr_alt (PmAltConLike cl) = ppr cl

     ppr_alt (PmAltLit lit)    = ppr lit

 instance Outputable p => Outputable (PmPatBind p) where

   ppr (PmPatBind PmGRHS { pg_grds = grds, pg_rhs = bind }) =

 instance Outputable PmEmptyCase where

   ppr (PmEmptyCase { pe_var = var }) =

   where

     go (Just doc) (_,     so_far) = (False, doc : so_far)

     go Nothing    (True,  so_far) = (True, so_far)

 isIfaceDataInstance :: IfaceTyConParent -> Bool

 isIfaceDataInstance IfNoParent = False

 -- the function.

 ppLlvmFunctionDecl :: IsDoc doc => LlvmFunctionDecl -> doc

 ppLlvmFunctionDecl (LlvmFunctionDecl n l c r varg p a)

         align = case a of

                      Just a' -> text " align" <+> int a'

                      Nothing -> empty

   LMVector l t -> "v" ++ show l ++ ppLlvmTypeShort t

   _ -> pprPanic "ppLlvmTypeShort" (ppLlvmType t)

 ppParams :: IsLine doc => LlvmParameterListType -> [LlvmParameter] -> doc

 ppParams varg p

 {-# SPECIALIZE ppParams :: LlvmParameterListType -> [LlvmParameter] -> SDoc #-}

 {-# SPECIALIZE ppParams :: LlvmParameterListType -> [LlvmParameter] -> HLine #-} -- see Note [SPECIALIZE to HDoc] in GHC.Utils.Outputable

 lessUnsafeCoerce :: Logger -> String -> a -> IO b

 lessUnsafeCoerce logger context what = do

     debugTraceMsg logger 3 $

     output <- evaluate (unsafeCoerce what)

     debugTraceMsg logger 3 (text "Successfully evaluated coercion")

     return output

         EmptyCaseForall tvb ->

           vcat [ text "Empty list of alternatives in" <+> pp_ctxt

                , hang (text "checked against a forall-type:")

                ]

         where

           pp_ctxt = case ctxt of

               <+> text "may fail for the following constructors:")

            2

            (hsep $ punctuate comma $

     TcRnBadFieldAnnotation n con reason -> mkSimpleDecorated $

       hang (pprBadFieldAnnotationReason reason)

          2 (text "on the" <+> speakNth n

   DerivErrNotWellKinded tc cls_kind _

     -> sep [ hang (text "Cannot derive well-kinded instance of form"

                          <+> quotes (pprClassPred cls cls_tys

                   2 empty

            , nest 2 (text "Class" <+> quotes (ppr cls)

                          <+> text "expects an argument of kind"

       ppr_eqn :: SDoc

       ppr_eqn =

         quotes (text "type" <+> ppr (mkTyConApp fam_tc pat_tys)

       suggestion :: SDoc

       suggestion = text "The arguments to" <+> quotes (ppr fam_tc)

                <+> text "pattern synonym, e.g.")

             2 (hang (text "pattern" <+> pp_name <+> pp_args <+> larrow

                      <+> ppr pat <+> text "where")

          where

            pp_name = ppr name

            pp_args = hsep (map ppr args)

         arrow, lollipop, larrow, darrow, arrowt, larrowt, arrowtt, larrowtt,

         lambda,

         lparen, rparen, lbrack, rbrack, lbrace, rbrace, underscore,

         ($+$),

         cat, fcat,

         hang, hangNotEmpty, punctuate, punctuateFinal,

 pprDeeper :: SDoc -> SDoc

 pprDeeper d = SDoc $ \ctx -> case sdocStyle ctx of

   PprUser q depth c ->

        deeper n = runSDoc d ctx{sdocStyle = PprUser q (PartWay (n-1)) c}

    in case depth of

          DefaultDepth -> deeper (sdocDefaultDepth ctx)

 trim :: Int -> [SDoc] -> [SDoc]

 trim _ []     = []

 trim n (d:ds) = d : trim (n-1) ds

 pprSetDepth :: Depth -> SDoc -> SDoc

            | otherwise        -> Pretty.quotes pp_d

 blankLine, dcolon, arrow, lollipop, larrow, darrow, arrowt, larrowt, arrowtt,

 blankLine  = docToSDoc Pretty.emptyText

 dcolon     = unicodeSyntax (char '∷') (text "::")

 arrowtt    = unicodeSyntax (char '⤜') (text ">>-")

 larrowtt   = unicodeSyntax (char '⤛') (text "-<<")

 lambda     = unicodeSyntax (char 'λ') (char '\\')

 semi, comma, colon, equals, space, underscore, dot, vbar :: IsLine doc => doc

 lparen, rparen, lbrack, rbrack, lbrace, rbrace :: IsLine doc => doc

         int, integer, float, double, rational, hex,

         -- ** Simple derived documents

         lparen, rparen, lbrack, rbrack, lbrace, rbrace,

         -- ** Wrapping documents in delimiters

 rbrack :: Doc -- ^ A ']' character

 lbrace :: Doc -- ^ A '{' character

 rbrace :: Doc -- ^ A '}' character

 semi   = char ';'

 comma  = char ','

 colon  = char ':'

 rbrack = char ']'

 lbrace = char '{'

 rbrace = char '}'

 spaceText, nlText :: TextDetails

 spaceText = Chr ' '