type instance Anno (FamilyResultSig (GhcPass p)) = EpAnnCO

 type instance Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (InjectivityAnn (GhcPass p)) = EpAnnCO

 type instance Anno (HsDerivingClause (GhcPass p)) = EpAnnCO

 type instance Anno (DerivClauseTys (GhcPass _)) = SrcSpanAnnA

 type instance Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

         | type                      { sL1 $1 (Nothing, mkHsOuterImplicit, $1) }

 capi_ctype : '{-# CTYPE' STRING STRING '#-}'

            | '{-# CTYPE'        STRING '#-}'

            |           { Nothing }

 mkTyData :: SrcSpan

          -> Bool

          -> NewOrData

          -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)

          -> Maybe (LHsKind GhcPs)

          -> [LConDecl GhcPs]

                                    tcdDataDefn = defn,

                                    tcdModifiers = [] })) }

            -> Maybe (LHsContext GhcPs)

            -> Maybe (LHsKind GhcPs)

            -> DataDefnCons (LConDecl GhcPs)

 mkDataFamInst :: SrcSpan

               -> NewOrData

               -> (Maybe ( LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs

                         , LHsType GhcPs)

               -> Maybe (LHsKind GhcPs)

 -}

 {-# LANGUAGE TypeFamilies #-}

 module GHC.Stg.Lint ( lintStgTopBindings ) where

 import GHC.Data.Bag         ( Bag, emptyBag, isEmptyBag, snocBag, bagToList )

 import Control.Monad

 import GHC.Core.Multiplicity (scaledThing)

 import GHC.Settings (Platform)

 import GHC.Core.TyCon (primRepCompatible, primRepsCompatible)

 ************************************************************************

 -}

               -> [LintLocInfo]     -- Locations

               -> IdSet             -- Local vars in scope

               -> Bag SDoc        -- Error messages so far

               -> (a, Bag SDoc)   -- Result and error messages (if any)

     }

 data LintFlags = LintFlags { lf_unarised :: !Bool

                            , lf_platform :: !Platform

 initL :: Platform -> DiagOpts -> Module -> Bool -> StgPprOpts -> IdSet -> LintM a -> Maybe SDoc

 initL platform diag_opts this_mod unarised opts locals (LintM m) = do

   if isEmptyBag errs then

       Nothing

   else

       Just (vcat (punctuate blankLine (bagToList errs)))

 instance Applicative LintM where

       (<*>) = ap

       (*>)  = thenL_

     (>>)  = (*>)

 thenL :: LintM a -> (a -> LintM b) -> LintM b

 thenL_ :: LintM a -> LintM b -> LintM b

 checkL :: Bool -> SDoc -> LintM ()

 checkL True  _   = return ()

     id_ty = idType id

 addErrL :: SDoc -> LintM ()

 addErr :: DiagOpts -> Bag SDoc -> SDoc -> [LintLocInfo] -> Bag SDoc

 addErr diag_opts errs_so_far msg locs

     mk_msg []      = msg

 addLoc :: LintLocInfo -> LintM a -> LintM a

 addInScopeVars :: [Id] -> LintM a -> LintM a

  -> let

         new_set = mkVarSet ids

 getLintFlags :: LintM LintFlags

 getStgPprOpts :: LintM StgPprOpts

 checkInScope :: Id -> LintM ()

  -> if nameIsLocalOrFrom mod (idName id) && not (id `elemVarSet` scope) then

         ((), addErr diag_opts errs (hsep [ppr id, dcolon, ppr (idType id),

                                     text "is out of scope"]) loc)

 import Data.Functor ((<&>))

 import Control.DeepSeq (NFData(..))

 {-

 ************************************************************************

 defaultCType :: String -> CType (GhcPass p)

 defaultCType =

 typeCheckCType :: CType GhcRn -> CType GhcTc

 typeCheckCType (CType x y z) = CType x (typeCheckHeader <$> y) z

 data CTypeGhc = CTypeGhc

   { cTypeSourceText :: SourceText

   , cTypeOtherText  :: SourceText

   }

   deriving (Data, Eq)

       return $ CTypeGhc

         { cTypeSourceText = str1

         , cTypeOtherText  = str2

         }

 instance NFData StaticTargetGhc where

   * Show `ExceptionContext` in `displayExceptionAnnotation` implementation of `WhileHandling` ([GHC #27456](https://gitlab.haskell.org/ghc/ghc/-/issues/27456))

   * Hide implementation details when throwing exceptions in throw and throwSTM. ([CLC proposal #387](https://github.com/haskell/core-libraries-committee/issues/387))

   * Change `hIsReadable` and `hIsWritable` such that they always throw a respective exception when encountering a closed or semi-closed handle, not just in the case of a file handle. ([CLC proposal #371](github.com/haskell/core-libraries-committee/issues/371))

   * Annotate `onException` continuation with `WhileHandling`. ([CLC Proposal #397](https://github.com/haskell/core-libraries-committee/issues/397))

   * Improve error message for `Data.Char.chr`. ([CLC Proposal #384](https://github.com/haskell/core-libraries-committee/issues/384))

      # excessive amounts of stack space. So we specifically set a low

      # stack limit and mark it as failing under a few conditions.

      [extra_run_opts('+RTS -K8m -RTS'),

      # JS doesn't support stack limit so the test sometimes passes just fine. Therefore the test is

      # marked as fragile.

      when(js_arch(), fragile(22921))],

 import GHC.Conc.Sync

 main :: IO ()

 import GHC.Internal.Data.Typeable (Typeable, TypeRep, cast)

 import qualified GHC.Internal.Data.Typeable as Typeable

    -- loop: GHC.Internal.Data.Typeable -> GHC.Internal.Err -> GHC.Internal.Exception

 import GHC.Internal.Show

 import GHC.Internal.Types (Bool(..))

 import GHC.Internal.Exception.Context

 -}

 class (Typeable e, Show e) => Exception e where

     toException   :: e -> SomeException

     fromException :: SomeException -> Maybe e

 -- | @since base-4.8.0.0

 instance Exception Void

 --

 -- @since base-3.0

 instance Exception SomeException where

     fromException = Just

     backtraceDesired (SomeException e) = backtraceDesired e

     displayException (SomeException e) = displayException e

 HasCallStack backtrace:

   error, called at ghc-e005.hs:12:10 in main:Main

      [js_skip,

       # This test is vulnerable to changes in allocation behaviour, so we disable it in some ways

       when(arch('wasm32'), skip),

      compile_and_run, ['-with-rtsopts -A8K'])

 # These tests need access to the internal RTS headers.

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

     let stp  = cTypeSourceText ext

         stct = cTypeOtherText  ext

     o' <- markAnnOpen'' o stp "{-# CTYPE"

     l1' <- case mh of

              Nothing -> return l1

                printStringAtAA l1 (toSourceTextWithSuffix srcH "" "")

     l2' <- printStringAtAA l2 (toSourceTextWithSuffix stct (unpackHText ct) "")

     c' <- markEpToken c

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

 type instance Anno (HsSigType DocNameI) = SrcSpanAnnA

 type instance Anno (BooleanFormula DocNameI) = SrcSpanAnnBF

 type instance Anno (OverlapMode DocNameI) = SrcSpanAnnA

 type instance Anno (Header DocNameI) = EpAnn AnnPragma

 type instance Anno (HsModifierOf (LocatedA (HsType DocNameI)) DocNameI) = SrcSpanAnnA

 type instance Anno (HsContextDetails DocNameI a) = SrcSpanAnnA