mkHsWildCardBndrs, mkHsPatSigType, mkHsTyPat,

         mkEmptyWildCardBndrs,

         mkHsForAllVisTele, mkHsForAllInvisTele,

         isHsKindedTyVar, hsBndrVar, hsBndrKind, hsTvbAllKinded,

         hsScopedTvs, hsScopedKvs, hsWcScopedTvs, dropWildCards,

         hsTyVarLName, hsTyVarName,

 hsLTyVarNames :: [LHsTyVarBndr flag (GhcPass p)] -> [IdP (GhcPass p)]

 hsLTyVarNames = mapMaybe hsLTyVarName

 hsForAllTelescopeBndrs :: HsForAllTelescope (GhcPass p) -> [LHsTyVarBndr ForAllTyFlag (GhcPass p)]

 hsForAllTelescopeBndrs (HsForAllVis   _ bndrs) = map (fmap (setHsTyVarBndrFlag Required)) bndrs

 hsForAllTelescopeBndrs (HsForAllInvis _ bndrs) = map (fmap (updateHsTyVarBndrFlag Invisible)) bndrs

 hsExplicitLTyVarNames :: LHsQTyVars (GhcPass p) -> [IdP (GhcPass p)]

 -- Explicit variables only

 hsAllLTyVarNames :: LHsQTyVars GhcRn -> [Name]

 -- All variables

 hsLTyVarLocNames :: Anno (IdGhcP p) ~ SrcSpanAnnN

                  => LHsQTyVars (GhcPass p) -> [LocatedN (IdP (GhcPass p))]

 -- | Get the kind signature of a type, ignoring parentheses:

 --

                               , hsq_explicit  = rn_bndrs })

                       body_remaining } }

   where

     -- The SrcSpan of the LHsQTyVars. For example, bndrs_loc would be the

     -- highlighted part in the class below:

 import GHC.Core.InstEnv

 import qualified GHC.Driver.DynFlags as DynFlags

 import GHC.Driver.Ppr

 import GHC.Plugins (TopLevelFlag (..))

 import GHC.Types.SourceText

 import GHC.Unit.State

       apps $

         map reL $

           (HsTyVar noAnn NotPromoted (reL (noUserRdr $ tcdName dat)))

 ppCtor

   sDocContext

   _dat

         | associated = id

         | otherwise = (<+> keyword "family")

       famSig = case result of

         NoSig _ -> empty

       hdr =

         hsep

           ( [keyword "type", ppBinder summary occ]

           )

       full = hdr <+> def

       def = case unLoc ltype of

   qual =

     hsep

       [ ppFamilyLeader associated info

       , ppResultSig result unicode qual

       , injAnn

       , whereBit

 ppClassHdr summ lctxt n tvs fds unicode qual =

   keyword "class"

     <+> (if not (null $ fromMaybeContext lctxt) then ppLContext lctxt unicode qual HideEmptyContexts else noHtml)

     <+> ppFds fds unicode qual

 ppFds :: [LHsFunDep DocNameI] -> Unicode -> Qualification -> Html

       ppLContext ctxt unicode qual HideEmptyContexts

       <+>

       -- T a b c ..., or a :+: b

       <+> case ks of

         Nothing -> mempty

         Just (L _ x) -> dcolon unicode <+> ppKind unicode qual x

 import GHC.Data.StringBuffer (StringBuffer)

 import qualified GHC.Data.StringBuffer as S

 import GHC.Driver.Session

 import GHC.HsToCore.Docs hiding (sigNameNoLoc)

 import GHC.Types.Name

 import GHC.Types.SrcLoc (advanceSrcLoc)

   [ HsValArg noExtField $ noLocA (case hsLTyVarName tv of

       Nothing -> HsWildCardTy noExtField

       Just nm -> HsTyVar noAnn NotPromoted (noLocA $ noUserRdr nm))

   ]

 --------------------------------------------------------------------------------

 -- * Making abstract declarations