GhcTc -> ppr v

       ppr_rhs = case dir of

           ImplicitBidirectional    -> ppr_simple equals

                                       (nest 2 $ pprFunBind mg)

 pprTicks :: SDoc -> SDoc -> SDoc

                   TyVarSig _ tv_bndr -> text "=" <+> ppr tv_bndr

       pp_inj = case mb_inj of

                  Just (L _ (InjectivityAnn _ lhs rhs)) ->

                  Nothing -> empty

       (pp_where, pp_eqns) = case info of

         ClosedTypeFamily mb_eqns ->

 instance OutputableBndrId p

        => Outputable (StandaloneKindSig (GhcPass p)) where

   ppr (StandaloneKindSig _ v ki)

 pp_condecls :: forall p. OutputableBndrId p => [LConDecl (GhcPass p)] -> SDoc

 pp_condecls cs

 ppr_expr (HsMultiIf _ alts)

   = hang (text "if") 3  (vcat $ toList $ NE.map ppr_alt alts)

   where ppr_alt (L _ (GRHS _ guards expr)) =

         ppr_alt (L _ (XGRHS x)) = ppr x

 -- special case: let ... in let ...

       ppr rnq `ppr_with_pending_tc_splices` ps

 ppr_expr (HsProc _ pat (L _ (HsCmdTop _ cmd)))

 ppr_expr (HsStatic _ e)

   = hsep [text "static", ppr e]

 matchSeparator :: HsMatchContext fn -> SDoc

 matchSeparator FunRhs{}         = text "="

 matchSeparator PatBindRhs       = text "="

 matchSeparator PatBindGuards    = text "="

 matchSeparator StmtCtxt{}       = text "<-"

     pp_inj_cond res inj = case filterByList inj binders of

        []  -> empty

     pp_rhs IfaceDataFamilyTyCon

       = ppShowIface ss (text "data")

          text "type role" <+> tyCon <+> hsep (map ppr froles)

 pprStandaloneKindSig :: SDoc -> IfaceType -> SDoc

 pprInfixIfDeclBndr :: ShowHowMuch -> OccName -> SDoc

 pprInfixIfDeclBndr (ShowSome _ (AltPpr (Just ppr_bndr))) name

        , IA_Arg (IfaceLitTy (IfaceStrTyLit n))

                 Required (IA_Arg ty Required IA_Nil) <- tys

        -> maybeParen ctxt_prec funPrec

        | IfaceTupleTyCon arity sort <- ifaceTyConSort info

        , not debug

   mkHsLitPV (L l a) = cmdFail l (ppr a)

   mkHsOverLitPV (L l a) = cmdFail (locA l) (ppr a)

   mkHsWildCardPV l = cmdFail l (text "_")

   mkHsExplicitListPV l xs _ = cmdFail l $

     brackets (pprWithCommas ppr xs)

   mkHsSplicePV (L l sp) = cmdFail l (pprUntypedSplice True Nothing sp)

         <td>Disable including self-recompilation information in interface files via <code>-fno-write-if-self-recomp</code>. If you are building a distribution you can enable this flag to produce more deterministic interface files.</td>

         <td><code>hash_unit_ids</code></td>

         <td>Include a package hash in the unit id of built packages</td>

     </tr>

 </table>

                 -> Bool,

     -- | Whether to build docs and which ones

     --   (haddocks, user manual, haddock manual)

 ```

 Hadrian provides several built-in flavours (`default`, `quick`, and a few

 others; see `hadrian/doc/flavours.md`), which can be activated from the command line,

 You can pass several `--docs=...` flags, Hadrian will combine

 their effects.

 ### Split sections

 You can build all or just a few packages with

     Context (..), vanillaContext, stageContext,

     -- * Expressions

     -- * Paths

     contextDir, buildPath, buildDir, pkgInplaceConfig, pkgSetupConfigFile, pkgSetupConfigDir,

 getBuildPath :: Expr Context b FilePath

 getBuildPath = expr . buildPath =<< getContext

 -- | Path to the directory containing haddock timing files, used by

 --   the haddock perf tests.

 haddockStatsFilesDir :: Action FilePath

   , enableHiCore

   , useNativeBignum

   , enableTextWithSIMDUTF

   , omitPragmas

   , completeSetting

     , "boot_nonmoving_gc" =: enableBootNonmovingGc

     , "dump_stg"         =: enableDumpStg

     , "hash_unit_ids"    =: enableHashUnitIds

     ]

   where (=:) = (,)

 enableHashUnitIds :: Flavour -> Flavour

 enableHashUnitIds flavour = flavour { hashUnitIds = True }

 -- | Build stage2 compiler with -fomit-interface-pragmas to reduce

 -- recompilation.

 omitPragmas :: Flavour -> Flavour

     ghcDocs :: Action DocTargets,

     -- | Whether to uses hashes or inplace for unit ids

     }

     useColor <- shakeColor <$> expr getShakeOptions

     let hasVanilla = elem vanilla ways

         hasDynamic = elem dynamic ways

     mconcat [ arg "-Wall"

             , arg "-Wcompat"

             , not useColor ? builder (Ghc CompileHs) ?

             , ghcLinkArgs

             , defaultGhcWarningsArgs

             , builder (Ghc CompileHs) ? arg "-c"

             , getInputs

             , arg "-o", arg =<< getOutput ]

     , ghcDebugAssertions = const False

     , ghcSplitSections   = False

     , ghcDocs            = cmdDocsArgs

     , hashUnitIds        = False }

 -- | Default logic for determining whether to build

   $ enableHaddock

   -- 3. Include unit id hashes

   $ enableHashUnitIds

   $ performanceFlavour { name = "release" }

 f ∷ ∀ (a ∷ ★ → ★) b. C a ⇒ a b

 f ∷ ∀ (a ∷ ★ → ★) b. C a ⇒ a b

 fmap ∷ ∀ (f ∷ ★ → ★) a b. Functor f ⇒ (a → b) → f a → f b

 class Functor f where

   fmap ∷ ∀ a b. (a → b) → f a → f b

   ...

   	-- Defined in ‘GHC.Internal.Base’

 Functor ∷ (★ → ★) → Constraint

 class Functor f where

   fmap ∷ ∀ a b. (a → b) → f a → f b

   (<$) ∷ ∀ a b. a → f b → f a

       (a ∷ k1).

     Datatype d ⇒

     t d f a → [Char]

 class Datatype d where

   datatypeName ∷ ∀ k1 (t ∷ k → (k1 → ★) → k1 → ★) (f ∷ k1 → ★)

                    (a ∷ k1).

 T8959b.hs:5:7: error: [GHC-83865]

     • Couldn't match expected type ‘Int → Int’ with actual type ‘()’

     • In the expression: ()

 T8959b.hs:8:7: error: [GHC-83865]

     • Couldn't match expected type ‘()’ with actual type ‘t0 → m0 t0’

 T8959b.hs:10:7: error: [GHC-83865]

     • Couldn't match expected type ‘(∀ a. a → a) → a1’

                   with actual type ‘()’

     • In the expression: () ∷ (∀ a. a → a) → a

       In an equation for ‘baz’: baz = () ∷ (∀ a. a → a) → a

 test('T20206', normal, ghci_script, ['T20206.script'])

 test('T20217', normal, ghci_script, ['T20217.script'])

 test('T20455', normal, ghci_script, ['T20455.script'])

 test('shadow-bindings', normal, ghci_script, ['shadow-bindings.script'])

 test('T925', normal, ghci_script, ['T925.script'])

 test('T7388', normal, ghci_script, ['T7388.script'])

 class X a b | a → b where

   to ∷ a → b

   {-# MINIMAL to #-}