-- Implicit Params

     , (mkTcOcc "IP", ipClassKey)

     -- Base strings Strings

     , (mkVarOcc "unpackCString#",     unpackCStringIdKey)

     , (mkVarOcc "unpackCStringUtf8#", unpackCStringUtf8IdKey)

     -- Known-key names that have BuiltinRules in ConstantFold

     , (mkVarOcc "unpackFoldrCString#",      unpackCStringFoldrIdKey)

     , (mkVarOcc "unpackFoldrCStringUtf8#",  unpackCStringFoldrUtf8IdKey)

 basicKnownKeyNames :: [Name]  -- See Note [Known-key names]

 basicKnownKeyNames

  = [

         -- FFI primitive types that are not wired-in.

         ptrTyConName, funPtrTyConName, constPtrConName,

         int8TyConName, int16TyConName, int32TyConName, int64TyConName,

         word8TyConName, word16TyConName, word32TyConName, word64TyConName,

         -- Plugins

         pluginTyConName

         , frontendPluginTyConName

         -- Unsafe coercion proofs

         , unsafeCoercePrimName

     ]

 -- End of ghc-bignum

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

 -- WithDict

 withDictClassName :: Name

 withDictClassName = clsQual gHC_MAGIC_DICT (fsLit "WithDict") withDictClassKey

 -- Unsafe coercion proofs

 unsafeCoercePrimName:: Name

 unsafeCoercePrimName    = varQual gHC_INTERNAL_UNSAFE_COERCE (fsLit "unsafeCoerce#") unsafeCoercePrimIdKey

 ptrTyConName      = tcQual   gHC_INTERNAL_PTR (fsLit "Ptr")    ptrTyConKey

 funPtrTyConName   = tcQual   gHC_INTERNAL_PTR (fsLit "FunPtr") funPtrTyConKey

 -- plugins

 pLUGINS :: Module

 pLUGINS = mkThisGhcModule (fsLit "GHC.Driver.Plugins")

 frontendPluginTyConName :: Name

 frontendPluginTyConName = tcQual pLUGINS (fsLit "FrontendPlugin") frontendPluginTyConKey

 constPtrConName :: Name

 constPtrConName =

     tcQual gHC_INTERNAL_FOREIGN_C_CONSTPTR (fsLit "ConstPtr") constPtrTyConKey

 {-

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

 smallArrayPrimTyConKey        = mkPreludeTyConUnique  187

 smallMutableArrayPrimTyConKey = mkPreludeTyConUnique  188

 callStackTyConKey :: KnownKey

 callStackTyConKey = mkPreludeTyConUnique 191

 typeRepIdKey          = mkPreludeMiscIdUnique 510

 mkTrFunKey            = mkPreludeMiscIdUnique 511

 -- Dynamic

 toDynIdKey :: KnownKey

 toDynIdKey            = mkPreludeMiscIdUnique 530

 mappendClassOpKey = mkPreludeMiscIdUnique 556

 mconcatClassOpKey = mkPreludeMiscIdUnique 557

 fromStaticPtrClassOpKey :: KnownKey

 fromStaticPtrClassOpKey = mkPreludeMiscIdUnique 560

 makeStaticKey :: KnownKey

 makeStaticKey = mkPreludeMiscIdUnique 561

 -- Unsafe coercion proofs

 unsafeEqualityProofIdKey, unsafeCoercePrimIdKey :: KnownKey

 unsafeEqualityProofIdKey = mkPreludeMiscIdUnique 570

 fromStaticPtrClassOpOcc = mkVarOcc "fromStaticPtr"

 newStablePtrIdOcc       = mkVarOcc "newStablePtr"

 returnIOIdOcc, bindIOIdOcc, thenIOIdOcc,

   printIdOcc, ioTyConOcc, ioDataConOcc :: KnownOcc

 returnIOIdOcc = mkVarOcc "returnIO"

 assertErrorIdOcc :: KnownOcc

 assertErrorIdOcc = mkVarOcc "assertError"

 -- ghci

 ghciIoClassOcc, ghciStepIoMOcc :: KnownOcc

 ghciIoClassOcc = mkTcOcc "GHCiSandboxIO"

 toAnnotationWrapperIdOcc = mkVarOcc "toAnnotationWrapper"

 -- CallStacks/Source locations

 {- *********************************************************************

 *                                                                      *

    , manyDataConTy, oneDataConTy

    , liftedRepTy, unliftedRepTy, zeroBitRepTy )

 import GHC.Builtin.KnownKeys

 import GHC.Core.Coercion.Axiom

     -- Text "Something"

     Just (tc,[txt])

       , Just str <- isStrLitTy txt -> ftext str

     -- ShowType t

     Just (tc,[_k,t])

     -- t1 :<>: t2

     Just (tc,[t1,t2])

         pprUserTypeErrorTy t1 <> pprUserTypeErrorTy t2

     -- t1 :$$: t2

     Just (tc,[t1,t2])

         pprUserTypeErrorTy t1 $$ pprUserTypeErrorTy t2

     -- An unevaluated type function

 import GHC.Core.Make (getMkStringIds)

 import GHC.Builtin.KnownKeys

 import GHC.Types.TyThing

 import GHC.Platform.Ways

   let dflags = hsc_dflags hsc_env

   mk_string <- getMkStringIds (fmap tyThingId . lookupKnownKeyGlobal hsc_env)

   pure $ StaticPtrOpts

     { opt_platform = targetPlatform dflags

 import GHC.Prelude

 import GHC.Types.Id

 import GHC.Core.Type

     -- We detect if the Id is unsafeUnpackJSStringUtf8## applied to a string literal,

     -- if so then we convert the unsafeUnpack to a call to h$decode.

     | [StgVarArg v] <- args

     -- See: https://gitlab.haskell.org/ghc/ghc/-/merge_requests/10588

     -- Comment by Josh Meredith  <josh.meredith@iohk.io>

     -- `typex_expr` can throw an error for certain bindings so it's important

     -- Test case T23479

     | [StgLitArg (LitString bs)] <- args

     , Just d <- decodeModifiedUTF8 bs

     , [top] <- concatMap typex_expr (ctxTarget ctx)

     = return . (,ExprInline) $ top |= toJExpr d

         --                    StaticPtr a -> p a

         ; fromStaticPtr <- newKnownOccMethod StaticOrigin

                                     fromStaticPtrClassOpOcc [p_ty]

         ; let wrap = mkWpEvVarApps [typeable_ev] <.> mkWpTyApps [expr_ty]

               static_expr_ty = mkTyConApp static_ptr_ty_con [expr_ty]

         ; return $ mkHsWrapCo co $

 import GHC.Builtin.WiredIn.Types

 import GHC.Builtin.WiredIn.Prim

 import GHC.Builtin.KnownKeys

 import GHC.Builtin.PrimOps ( PrimOp(..) )

 import GHC.Builtin.PrimOps.Ids ( primOpId )

 import GHC.Types.FieldLabel

 import GHC.Types.SafeHaskell

 import GHC.Types.Name.Reader

 import GHC.Types.Var.Env ( VarEnv )

 import GHC.Types.Id

       -- see Note [No Typeable for polytypes or qualified types]

   -- Now cases that do work

   | Just (tc, ks) <- splitTyConApp_maybe t -- See Note [Typeable (T a b c)]

   , onlyNamedBndrsApplied tc ks            = doTyConApp clas t tc ks

   -- Typeable is implied by KnownNat/KnownSymbol. In the case of a type literal

   -- we generate a sub-goal for the appropriate class.

   -- See Note [Typeable for Nat and Symbol]

                   ; let kc_pred    = mkClassPred kc_clas [ t ]

                         mk_ev [ev] = evTypeable t $ EvTypeableTyLit (EvExpr ev)

                         mk_ev _    = panic "doTyLit"

 import GHC.Iface.Env( newGlobalBinder )

 import GHC.Builtin.Modules( gHC_TYPES, gHC_PRIM )

 import GHC.Builtin.KnownOccs

 import GHC.Builtin.WiredIn.Prim ( primTyCons )

 import GHC.Builtin.WiredIn.Types

          KindReps once in GHC.Types. These are referred to as "built-in"

          KindReps below.

   (GPT7) Even though KindReps aren't inlined, this scheme still has more of an

          effect on compilation time than I'd like. This is especially true in

          the case of families of type constructors (e.g. tuples and unboxed

     mod_fpr = fingerprintString $ moduleNameString $ moduleName mod

     pkg_fpr = fingerprintString $ unitString $ moduleUnit mod

 todoForExportedKindReps kinds = do

     trKindRepTy <- mkTyConTy <$> tcLookupKnownOccTyCon kindRepTyConOcc

 -- | Generate TyCon bindings for a set of type constructors

 mkTypeRepTodoBinds :: [TypeRepTodo] -> TcM TcGblEnv

 -- | We generate `KindRep`s for a few common kinds, so that they

 -- can be reused across modules.

 builtInKindReps =

     ]

   where

     star = liftedTypeKind

 initialKindRepEnv = foldlM add_kind_rep emptyTypeMap builtInKindReps

   where

     add_kind_rep acc (k,n) = do

         return $! extendTypeMap acc k (id, Nothing)

         -- The TypeMap looks through type synonyms

 import GHC.Types.Id

 import GHC.Builtin

 import GHC.Builtin.KnownKeys( unsatisfiableIdKey

                             , isStringClassKey

 import GHC.Builtin.Modules ( gHC_INTERNAL_TYPEERROR )

 import GHC.Builtin.WiredIn.Types

 import GHC.Builtin.WiredIn.Ids ( unboxedUnitExpr )

   | ClassPred cls tys <- classifyPredType (ctPred ct)

   , isJust (isExceptionContextPred cls tys)

   = do { warnTcS $ TcRnDefaultedExceptionContext (ctLoc ct)

        ; let ev = ctEvidence ct

              ev_tm = EvExpr (evWrapIPE (ctEvPred ev) (Var empty_ec_id))

        ; setDictIfWanted ev EvCanonical ev_tm

 import GHC.Types.Var.Env

 import GHC.Types.SrcLoc

 import GHC.Utils.Monad ( concatMapM )

 import GHC.Utils.Outputable

 evCallStack :: TcPredType -> EvCallStack -> TcS EvExpr

 -- See Note [Overview of implicit CallStacks] in GHC.Tc.Types.Evidence

 evCallStack _ EvCsEmpty

 evCallStack pred (EvCsPushCall fs loc tm)

   = do { df <- getDynFlags

        ; m  <- getModule

 import qualified GHC.Tc.Utils.TcMType  as TcM

 import qualified GHC.Tc.Instance.Class as TcM( matchGlobalInst, ClsInstResult(..) )

 import qualified GHC.Tc.Utils.Env      as TcM

 import GHC.Tc.Zonk.Monad ( ZonkM )

 import qualified GHC.Tc.Zonk.TcType  as TcM

 import GHC.Tc.Types.CtLoc

 import GHC.Tc.Types.Constraint

 import GHC.Core.Make

 import GHC.Core.Type

 updSolvedDicts what dict_ct@(DictCt { di_cls = cls, di_tys = tys, di_ev = ev })

   | isWanted ev

   , instanceReturnsDictCon what

        ; let contains_callstack_or_exceptionCtx =

                mightMentionIP

                  (const True)

     -- per Note [Using typesAreApart when calling mightMentionIP].

     --

     -- See Note [Using isCallStackTy in mightMentionIP].

            ; case mb_tc of

               Just tc ->

                 return $ \ ty -> not (typesAreApart ty (mkTyConTy tc))

       | Just ty' <- coreView ty

       = go ty'

     go (TyConApp tc tys)

       , _kind : msg : _ <- tys

               -- There may be more than 2 arguments, if the type error is

               -- used as a type constructor (e.g. at kind `Type -> Type`).

 import GHC.Types.Name

 import GHC.Types.Var ( varType )

 import GHC.Iface.Syntax ( showToHeader )

 import GHC.Types.SrcLoc as SrcLoc

 import qualified GHC.Parser.Lexer as Lexer

 import GHC.Parser.Header ( toArgs )

             let stringTy :: LHsType GhcPs

                 stringTy = nlHsTyVar NotPromoted stringTyCon_RDR

                 ioM :: LHsType GhcPs -- AZ

                 body = nlHsVar compose_RDR `mkHsApp` (nlHsPar step)

                                            `mkHsApp` (nlHsPar expr)

                 tySig = mkHsWildCardBndrs $ noLocA $ mkHsImplicitSigType $

   ghciTyConName <- GHC.getGHCiMonad

   let stringTy = nlHsTyVar NotPromoted stringTyCon_RDR

       ghciM = nlHsTyVar NotPromoted (Exact ghciTyConName) `nlHsAppTy` stringTy

       tySig = mkHsWildCardBndrs $ noLocA $ mkHsImplicitSigType $

               nlHsFunTy ghciM ioM

   return $ noLocA $ ExprWithTySig noAnn body tySig

     -- WithDict

     , WithDict

     -- Unsatisfiable

     , Unsatisfiable, unsatisfiable

     -- Static pointers

     , IsStatic( fromStaticPtr ), makeStatic

     -- Stable pointers

     , StablePtr, newStablePtr

     , CS.unpackAppendCStringUtf8#, CS.cstringLength#

     , eqString, inline

     , UnsafeEquality( UnsafeRefl ), unsafeEqualityProof

     -- Typeable and type representations

     , Body, normalB, guardedB

     , Guard, normalGE, patGE

     -- GHCi

     , GHCiSandboxIO(ghciStepIO)

     -- Callstacks

     ) where

 import GHC.Internal.Base hiding( foldr )

 import Data.String( IsString )

 import GHC.Internal.Ix

 import GHC.Internal.Magic.Dict( WithDict )

 import GHC.Internal.Enum

 import GHC.Internal.Data.Dynamic( toDyn )

 import GHC.Internal.Data.Data

 import GHC.Internal.OverloadedLabels( fromLabel )

 import GHC.Internal.Records

 import GHC.Internal.CString as CS

 import GHC.Internal.System.IO( print )

 import qualified GHC.Internal.IsList as IL

 import GHC.Internal.Err( error )

 import GHC.Internal.Unsafe.Coerce( UnsafeEquality(..), unsafeEqualityProof )

 import GHC.Internal.StaticPtr.Internal( makeStatic )

 import GHC.Internal.Stable( StablePtr, newStablePtr )

 import GHC.Internal.TH.Lift

 import GHC.Internal.TH.Monad

 import GHC.Internal.TopHandler

 import GHC.Internal.GHCi

 import GHC.Internal.Desugar (toAnnotationWrapper)

 import GHC.Internal.Stack.Types

 {-# LANGUAGE GADTs #-}

 {-# OPTIONS_HADDOCK not-home #-}

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

 -- |

 -- Module      :  GHC.Internal.Exception.Context

 {-# LANGUAGE NoImplicitPrelude #-}

 module GHC.Internal.Exception.Context where

 {-# LANGUAGE UnliftedFFITypes #-}

 {-# LANGUAGE UnboxedTuples #-}

 module GHC.Internal.JS.Prim ( JSVal(..), JSVal#

                    , JSException(..)

                    , WouldBlockException(..)

 -- we hide this module from haddock to enforce GHC.Internal.Stack as the main

 -- access point.

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

 -- |

 -- Module      :  GHC.Internal.Stack.Types

 -- NegativeLiterals: see Note [Fixity of (->)]

 {-# OPTIONS_HADDOCK print-explicit-runtime-reps #-}

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

 -- |