wiredInIds, ghcPrimIds,

         realWorldPrimId,

         voidPrimId, voidArgId,

         nospecId, nospecIdName,

         pcRepPolyId,

         unboxedUnitExpr,

 import GHC.Types.Id

 import GHC.Types.Id.Info

 import GHC.Types.InlinePragma

 import GHC.Tc.Types.Origin

 import GHC.Tc.Utils.TcType as TcType

 import GHC.Data.FastString

 here.

 Note [ghcPrimIds (aka pseudoops)]

 The ghcPrimIds

   * Are exported from GHC.Prim (see ghcPrimExports, used in ghcPrimInterface)

     -- seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b

     ty  =

       mkInfForAllTy runtimeRep2TyVar

     concs = mkRepPolyIdConcreteTyVars

     arity = 2

     info = noCafIdInfo

     -- noinline :: forall r (a :: TYPE r). a -> a

     ty   = mkInfForAllTy runtimeRep1TyVar   $

 noinlineConstraintId :: Id -- See Note [noinlineId magic]

 noinlineConstraintId = pcMiscPrelId noinlineConstraintIdName ty info

   where

     info = noCafIdInfo

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

 nospecId :: Id -- See Note [nospecId magic]

                        `setArityInfo`      arity

     -- oneShot :: forall {r1 r2} (a :: TYPE r1) (b :: TYPE r2). (a -> b) -> (a -> b)

     ty  = mkInfForAllTys  [ runtimeRep1TyVar, runtimeRep2TyVar ] $

           mkVisFunTyMany fun_ty fun_ty

     x' = setOneShotLambda x  -- Here is the magic bit!

     rhs = mkLams [ runtimeRep1TyVar, runtimeRep2TyVar

                  , body, x'] $

           Var body `App` Var x'

     arity = 2

     concs = mkRepPolyIdConcreteTyVars

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

 {- Note [Wired-in Ids for rebindable syntax]

                        `setUnfoldingInfo`  mkCompulsoryUnfolding rhs

                        `setArityInfo`      arity

     ty  = mkInfForAllTys  [runtimeRep1TyVar,runtimeRep2TyVar, multiplicityTyVar1] $

           exprType body

     mult = mkTyVarTy multiplicityTyVar1 :: Mult

     xmult = setIdMult x mult

     rhs  = mkLams [ runtimeRep1TyVar, runtimeRep2TyVar, multiplicityTyVar1

     body = mkLams [f,xmult] $ App (Var f) (Var xmult)

     arity = 2

     concs = mkRepPolyIdConcreteTyVars

 -- See Note [Left and right sections] in GHC.Rename.Expr

 -- See Note [Wired-in Ids for rebindable syntax]

                        `setArityInfo`      arity

     ty  = mkInfForAllTys  [runtimeRep1TyVar,runtimeRep2TyVar,runtimeRep3TyVar

                           , multiplicityTyVar1, multiplicityTyVar2 ] $

           exprType body

     mult1 = mkTyVarTy multiplicityTyVar1

     mult2 = mkTyVarTy multiplicityTyVar2

     xmult = setIdMult x mult1

     ymult = setIdMult y mult2

     rhs  = mkLams [ runtimeRep1TyVar, runtimeRep2TyVar, runtimeRep3TyVar

                   , multiplicityTyVar1, multiplicityTyVar2

     body = mkLams [f,ymult,xmult] $ mkVarApps (Var f) [xmult,ymult]

     arity = 3

     concs =

       mkRepPolyIdConcreteTyVars

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

 Note [noinlineId magic]

 ~~~~~~~~~~~~~~~~~~~~~~~

 Wrinkles

      Constraint; e.g.

                     noinline @(Eq Int) $dfEqInt

 Note [nospecId magic]

 ~~~~~~~~~~~~~~~~~~~~~

         alphaConstraintTyVar, alphaConstraintTy,

         levPolyAlphaTyVar, levPolyBetaTyVar,

         levPolyAlphaTyVarSpec, levPolyBetaTyVarSpec,

         levPolyAlphaTy, levPolyBetaTy,

 runtimeRep1Ty = mkTyVarTy runtimeRep1TyVar

 runtimeRep2Ty = mkTyVarTy runtimeRep2TyVar

 runtimeRep3Ty = mkTyVarTy runtimeRep3TyVar

   = mkTemplateTyVars [ mk_TYPE_app runtimeRep1Ty

                      , mk_TYPE_app runtimeRep2Ty

 levity1TyVar, levity2TyVar :: TyVar

 (levity2TyVar : levity1TyVar : _) -- NB: levity2TyVar before levity1TyVar

 import GHC.Types.Var    ( isTyCoVar )

 import GHC.Builtin.WiredIn.Prim( realWorldStatePrimTy )

 import qualified GHC.Data.List.Infinite as Inf

 import GHC.Data.Maybe   ( isNothing, orElse, mapMaybe )

              call' = mkApps (Var fun) [mkTyArg rr', mkTyArg new_runrw_res_ty, arg']

        ; rebuild_go env call' outer_cont }

   , ApplyToTy  { sc_cont = cont1 } <- cont

   , ApplyToTy  { sc_cont = cont2 } <- cont1

   , ApplyToVal { sc_cont = cont3, sc_arg = the_call, sc_cast = arg_mco

        ; let call_env = updMode updModeForNoInline $

                         arg_se `setInScopeFromE` env

        ; (floats1, call') <- simplExprF call_env inner_fun call_cont

        ; (floats2, res) <- rebuild env noinline_expr rest_cont

        ; return (floats2 `addFloats` floats1 , res) }

 -- | The key type representing kinds in the compiler.

 type Kind = Type

 type RuntimeRepType = Type

 -- | Type synonym used for types of kind Levity.

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

 -- Sees if the argument is of form (TYPE rep) or (CONSTRAINT rep)

 -- and if so returns which, and the runtime rep

 --

 import GHC.Builtin.WiredIn.Prim ( eqPrimTyCon, eqReprPrimTyCon )

 import GHC.Builtin.WiredIn.Types ( heqTyCon )

 import GHC.Iface.Syntax

 import GHC.Data.FastString

 toIfaceVar v

     | isBootUnfolding (idUnfolding v)

     = -- See Note [Inlining and hs-boot files]

       IfaceExt name      -- Don't use mkIfaceApps, or infinite loop

     | Just fcall <- isFCallId_maybe v = IfaceFCall fcall (toIfaceType (idType v))

   where

     name = idName v

     ty   = idType v

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

 toIfaceLFInfo :: Name -> LambdaFormInfo -> IfaceLFInfo

     1. When we serialize out unfoldings to IfaceExprs (toIfaceVar),

     for every variable reference we see if we are referring to an

     'Id' that came from an hs-boot file.  If so, we add a `noinline`

     in GHC.Types.Id.Make

     2. But how do we know if a reference came from an hs-boot file

 import GHC.Builtin.PrimOps.Ids

 import GHC.Builtin.WiredIn.Types

 import GHC.Builtin.WiredIn.Prim

 import GHC.Core.Utils

 import GHC.Core.Opt.Arity

       -- See Note [nospecId magic] in GHC.Types.Id.Make

 eliminateMagicCall f (AIApp Type{} : AIApp Type{} : AIApp arg : args)

     -- Replace (noinline a) with a

     -- See Note [noinlineId magic] in GHC.Types.Id.Make

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

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

        ; return magic_pair }

   | otherwise

        ; let [unsafe_refl_data_con] = tyConDataCons unsafe_equality_tc

              rhs = mkLams [ runtimeRep1TyVar, runtimeRep2TyVar

                           , x ] $

                    mkSingleAltCase scrut1

                                    (mkWildValBinder ManyTy scrut1_ty)

                    Var x `mkCast` x_co

              [x, rr_cv, ab_cv] = mkTemplateLocals

                , rr_cv_ty    -- rr_cv :: r1 ~# r2

                , ab_cv_ty    -- ab_cv :: (alpha |> alpha_co ~# beta)

                ]

                                                              runtimeRep1Ty

                                                              runtimeRep2Ty

              (scrut2, scrut2_ty, ab_cv_ty) = unsafe_equality (mkTYPEapp runtimeRep2Ty)

              -- alpha_co :: TYPE r1 ~# TYPE r2

              -- alpha_co = TYPE rr_cv

              alpha_co = mkTyConAppCo Nominal tYPETyCon [mkCoVarCo rr_cv]

              -- x_co :: alpha ~R# beta

                     mkSubCo (mkCoVarCo ab_cv)

                                 `setArityInfo`     arity

              ty = mkSpecForAllTys [ runtimeRep1TyVar, runtimeRep2TyVar

              arity = 1

              concs = mkRepPolyIdConcreteTyVars

                      unsafeCoercePrimName

              id   = mkExportedLocalId (RepPolyId concs) unsafeCoercePrimName ty `setIdInfo` info

   , Just (cls, dict_dc) <- isUnaryClassTyCon_maybe dict_tc

   , [inst_meth_ty] <- dataConInstArgTys dict_dc dict_args

   = do { sv <- mkSysLocalM (fsLit "withDict_s") ManyTy mty

        ; wd_cls <- tcLookupKnownKeyClass withDictClassKey

        -- Given ev_expr : mty ~N# inst_meth_ty, construct the method of

        --   \@(r :: RuntimeRep) @(a :: TYPE r) (sv :: mty) (k :: cls => a) ->

        --     k (MkC tys (sv |> sub co2))

        ; let evWithDict ev_expr

                  Var k `App` (evUnaryDictAppE cls dict_args meth_arg)

                where

                  meth_arg = Var sv `mkCast` mkSubCo (evExprCoercion ev_expr)

 -- | The call @noinline f@ arranges that @f@ will not be inlined.

 -- It is removed during CorePrep so that its use imposes no overhead

 -- (besides the fact that it blocks inlining.)

 -- | The 'lazy' function restrains strictness analysis a little. The

 -- call @lazy e@ means the same as @e@, but 'lazy' has a magical

   ( primOpId )

 import GHC.Builtin.WiredIn.Prim

   ( runtimeRep1Ty, runtimeRep1TyVar

   )

 import GHC.Core

         [ Type liftedDataConTy

         , Type liftedRepTy

         , Type intTy

         ]

   , ("raise# OK 2", ) $

       -- raise# @Lifted @r

 -- These will be considered in-scope by the Core Lint checks.

 in_scope :: [ Id ]

 main :: IO ()

 main = do

 ppTyVar "b" = nonDepTyVarBinder "betaTyVarSpec"

 ppTyVar "c" = nonDepTyVarBinder "gammaTyVarSpec"

 ppTyVar "s" = nonDepTyVarBinder "deltaTyVarSpec"

 -- See Note [Levity and representation polymorphic primops] in primops.txt.pp

 ppTyVar "a_reppoly"

   = PrimOpTyVarBinder

   { inferredTyVarBinders = ["runtimeRep1TyVarInf"]

 ppTyVar "b_reppoly"

   = PrimOpTyVarBinder

   { inferredTyVarBinders = ["runtimeRep2TyVarInf"]

 ppTyVar "a_levpoly"

   = PrimOpTyVarBinder

   { inferredTyVarBinders = ["levity1TyVarInf"]

 ppType (TyVar "c")                      = "gammaTy"

 ppType (TyVar "s")                      = "deltaTy"

 -- See Note [Levity and representation polymorphic primops] in primops.txt.pp

 ppType (TyVar "a_levpoly")              = "levPolyAlphaTy"

 ppType (TyVar "b_levpoly")              = "levPolyBetaTy"