type instance XStatic        GhcPs = EpToken "static"

 type instance XStatic        GhcRn = NoExtField

   -- StaticPtr is a bit tricky (see #20150)

 type instance XEmbTy         GhcPs = EpToken "type"

                                       -- than in the typechecked AST.

 hsExprType (HsUntypedSplice ext _) = dataConCantHappen ext

 hsExprType (HsProc _ _ lcmd_top) = lhsCmdTopType lcmd_top

 hsExprType (HsPragE _ _ e) = lhsExprType e

 hsExprType (HsEmbTy x _) = dataConCantHappen x

 hsExprType (HsHole (_, (HER _ ty _))) = ty

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

 See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable

 for an overview.

 -}

   = do { dflags <- getDynFlags

        ; make_static_id <- dsLookupGlobalId makeStaticName

        ; expr_ds        <- dsLExpr expr

        -- The static expression can have free type variables,

        -- which we should quantify.  We can also have free Ids,

        -- but they will be bound at top level

              static_fvs :: [Var]

              static_fvs = scopedSort $

              static_rhs = mkLams static_fvs $

                           mkCoreApps (Var make_static_id) [ Type ty, srcLoc, expr_ds ]

        ; emitStaticBinds [(static_id, static_rhs)]

 {- Note [Desugaring record construction]

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

 import GHC.Driver.DynFlags

 import GHC.Builtin.Names

 import GHC.Builtin.Types ( nilDataConName )

 import GHC.Types.Basic (TypeOrKind (TypeLevel))

 import GHC.Types.FieldLabel

                                     [liftedTypeKind, expr_ty]

         -- Wrap the static form with the 'fromStaticPtr' call.

         ; static_ptr_ty_con <- tcLookupTyCon staticPtrTyConName

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

         ; return $ mkHsWrapCo co $

         }

 tcExpr (HsEmbTy _ _)      _ = failWith (TcRnIllegalTypeExpr TypeKeywordSyntax)

       --    and affects how names are rendered in error messages

       --  * the local env exposes the local Ids to simplifyTop,

       --    so that we get better error messages (monomorphism restriction)

         -- Emit Typeable bindings

       ; tcg_env <- setGblEnv tcg_env $

         -- Even simplifyTop may do some unification.

         -- This pass also warns about missing type signatures

       ; (id_env, ev_binds', binds', fords', imp_specs', rules', pat_syns')

       --------- Run finalizers --------------

       -- Finalizers must run after constraints are simplified, lest types

       --------- Emit the ':Main.main = runMainIO main' declaration ----------

       -- Do this /after/ rnExports, so that it can consult

       -- the tcg_exports created by rnExports

            <- restoreEnvs (tcg_env, tcl_env) $

               do { (tcg_env, lie) <- captureTopConstraints $

                                      checkMain explicit_mod_hdr export_ies

                  ; ev_binds <- simplifyTop lie

       ; failIfErrsM    -- Stop now if if there have been errors

                        -- Continuing is a waste of time; and we may get debug

       -- and main. This won't give rise to any more finalisers as you

       -- can't nest finalisers inside finalisers.

       ; (id_env_mf, ev_binds_mf, binds_mf, fords_mf, imp_specs_mf, rules_mf, patsyns_mf)

       ; let { !final_type_env = tcg_type_env tcg_env

                                 `plusTypeEnv` id_env_mf

       ; setGlobalTypeEnv tcg_env' final_type_env

    }

              -> TcM (TypeEnv, Bag EvBind, LHsBinds GhcTc,

                        [LForeignDecl GhcTc], [LTcSpecPrag], [LRuleDecl GhcTc], [PatSyn])

   = {-# SCC "zonkTopDecls" #-}

     setGblEnv tcg_env $ -- This sets the GlobalRdrEnv which is used when rendering

                         --   error messages during zonking (notably levity errors)

 -- | Runs TH finalizers and renames and typechecks the top-level declarations

 -- that they could introduce.

         tcLookupLocatedGlobalId, tcLookupLocatedTyCon,

         tcLookupLocatedClass, tcLookupAxiom,

         lookupGlobal, lookupGlobal_maybe,

         failIllegalTyCon, failIllegalTyVar,

         -- Local environment

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Utils.TcMType ( tcCheckUsage )

 import GHC.Tc.Types.LclEnv

 import GHC.Core.InstEnv

 import GHC.Core.DataCon ( DataCon, dataConTyCon, flSelector )

 import GHC.Tc.Errors.Types.PromotionErr

 import {-# SOURCE #-} GHC.Tc.Errors.Hole (getHoleFitDispConfig)

 import Control.Monad

 import Data.IORef

 import Data.List          ( intercalate )

   | otherwise = tcg_env { tcg_binds = foldr (++)

                                             (tcg_binds tcg_env)

                                             binds }

 {-

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

 *                                                                      *

   -- * Type constraints

   newTcEvBinds, newNoTcEvBinds, cloneEvBindsVar,

   getTcEvBindsMap, setTcEvBindsMap, updTcEvBinds,

   getTcEvTyCoVars, chooseUniqueOccTc,

   getConstraintVar, setConstraintVar,

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

 -}

 newTcEvBinds :: TcM EvBindsVar

 newTcEvBinds = do { binds_ref <- newTcRef emptyEvBindMap

                   ; tcvs_ref  <- newTcRef []

         ; return (HsProc x new_pat new_body) }

 -- StaticPointers extension

   = do new_ty <- zonkTcTypeToTypeX ty

 zonkExpr (HsEmbTy x _) = dataConCantHappen x

 zonkExpr (HsQual x _ _) = dataConCantHappen x