, (mkDataOcc ":$$:",      typeErrorVAppendDataConKey)

     , (mkDataOcc "ShowType",  typeErrorShowTypeDataConKey)

     -- Plugins

     , (mkTcOcc "Plugin", pluginTyConKey)

     , (mkTcOcc "FrontendPlugin", frontendPluginTyConKey)

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

 basicKnownKeyNames

  = [

     ]

 -- End of ghc-bignum

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

 -- WithDict

 withDictClassName :: Name

 withDictClassName = clsQual gHC_MAGIC_DICT (fsLit "WithDict") withDictClassKey

 genericClassKeys :: [KnownKey]

 genericClassKeys = [genClassKey, gen1ClassKey]

 import GHC.Types.TypeEnv

 import GHC.Types.Name

 import GHC.Types.Name.Set

 import GHC.Types.Name.Ppr

 import GHC.Types.HpcInfo

 import Data.IORef

 import GHC.Iface.Make (mkRecompUsageInfo)

 import GHC.Runtime.Interpreter (interpreterProfiled)

 {-

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

   -- optimization: check whether we're in a magic module before looking

   -- at all the ids

   = do { this_mod <- getModule

        ; if this_mod `elemModuleSet` magicDefnModules

          then traverse patchMagicDefn pairs

          else return pairs }

 patchMagicDefn :: (Id, CoreExpr) -> DsM (Id, CoreExpr)

 patchMagicDefn orig_pair@(orig_id, orig_rhs)

   = do { magic_pair@(magic_id, _) <- mk_magic_pair orig_id orig_rhs

        -- Patching should not change the Name or the type of the Id

   | otherwise

   = return orig_pair

                       -> DsM (Id, CoreExpr) -- new Id and RHS

                )]

 mkUnsafeCoercePrimPair :: Id -> CoreExpr -> DsM (Id, CoreExpr)

 -- See Note [Wiring in unsafeCoerce#] for the defn we are creating here

 mkUnsafeCoercePrimPair _old_id old_expr

   = do { unsafe_equality_proof_id <- dsLookupKnownKeyId unsafeEqualityProofIdKey

        ; unsafe_equality_tc       <- dsLookupKnownKeyTyCon unsafeEqualityTyConKey

        ; let [unsafe_refl_data_con] = tyConDataCons unsafe_equality_tc

       -- We use Any rather than a dummy type such as () because of

       -- the rules of unsafeCoerce#; see Unsafe/Coerce.hs for the details.

            -- We use unsafeCoerce# here because of (U11) in

            -- Note [Implementing unsafeCoerce] in base:Unsafe.Coerce

 import GHC.Prelude

 import GHC.Builtin.WiredIn.Types

 import GHC.Core.Coercion

 import GHC.Data.FastString     ( FastString, fsLit )

 import Control.Monad      ( void )

 {- Note [Concrete overview]

   -- in the correct information in the desugarer).

   -- So, for the time being, we manually inspect the type of the original,

   -- unpatched Id to retrieve which of its outer forall-d tyvars should be concrete.

   , (a_rep:_b_rep:a:_b:_, _) <- tcSplitForAllTyVars $ idType id

   -- NB: only check the argument representation, not the result representation.

   -- This is because the following is OK:

   --   unsafeCoerceWordRep = unsafeCoerce#

   = mkNameEnv

     [(tyVarName a_rep, ConcreteFRR $ FixedRuntimeRepOrigin (mkTyVarTy a)

                                    $ mkArgPos 1 Top)]

   | otherwise

     , CS.unpackAppendCStringUtf8#, CS.cstringLength#

     , eqString, inline

     -- Typeable and type representations

     , SomeTypeRep( SomeTypeRep ), TR.Module( Module )

   -- LANGUAGE pragmas: see Note [IP: implicit parameter class]

 {-# OPTIONS_HADDOCK not-home #-}

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

 -- |

 -- Module      :  GHC.Internal.Classes.IP

 -}

 import GHC.Internal.Classes ( Eq( (==) ), (&&) )

 import GHC.Internal.Types

 default ()