-- Note [hsc_type_env_var hack]

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 -- eventually it is the mutable variable that is queried from

 -- if_rec_types to get a TypeEnv.  So, clearly, it's something

 -- related to knot-tying (see Note [Tying the knot]).

 -- hsc_type_env_var is used in two places: initTcRn (where

 -- (where it initializes if_rec_types).

 --

 -- But why do we need a way to feed a mutable variable in?  Why

 -- typechecking?  The problem is we need to knot-tie the

 -- EPS, and we may start adding things to the EPS before type

 -- checking starts.

         hsc_type_env_vars :: KnotVars (IORef TypeEnv)

                 -- ^ Used for one-shot compilation only, to initialise

         , hsc_interp :: Maybe Interp

                 -- ^ target code interpreter (if any) to use for TH and GHCi.

   mg <- downsweepThunk hsc_env mod_summary

   -- Need to set the knot-tying mutable variable for interface

   -- See also Note [hsc_type_env_var hack]

   type_env_var <- newIORef emptyNameEnv

   let hsc_env' =

 dsGetKnownKeySource

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; if rebindable_path

          else return KKNS_FromModule }

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

 data DsGblEnv

   = DsGblEnv

   { ds_mod          :: Module             -- For SCC profiling

   , ds_gbl_rdr_env  :: GlobalRdrEnv

         -- The GlobalRdrEnv is needed for the following reasons:

         --    - to know what newtype constructors are in scope

         --    - to check whether all members of a COMPLETE pragma are in scope

         --    - when looking up know-key names

   , ds_name_ppr_ctx :: NamePprCtx

   , ds_msgs    :: IORef (Messages DsMessage) -- Diagnostic messages

   , ds_if_env  :: (IfGblEnv, IfLclEnv)    -- Used for looking up global,

 ********************************************************************* -}

 data KnownKeyNameSource

       -- Look up the known-key name in this GlobalRdrEnv, which

       -- is the top-level scope of the current module.

       -- This happens when -frebindable-known-key-name is set, usually when

        -- is /not/ set

 instance Outputable KnownKeyNameSource where

 lookupKnownKeyThing :: HasDebugCallStack

                     => KnownKey -> KnownKeyNameSource

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

        ; case mb_name of

              Failed err     -> return (Failed err)

 lookupKnownKeyName :: HasDebugCallStack

                    => KnownKey -> KnownKeyNameSource

              | otherwise

              -> return (Failed (MissingKnownKey1 key)) }

   -- Just gbl_rdr_env: we have -frebindable-known-key-names on, and

   --                   here is the top-level GlobalRdrEnv

   -- Look up the /un-qualified/ known-key OccName in the GlobalRdrEnv

 lookupKnownOccThing :: HasDebugCallStack

                     => KnownOcc -> KnownKeyNameSource

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

        ; case mb_name of

              Failed err     -> return (Failed err)

 lookupKnownOccName :: HasDebugCallStack

                    => KnownOcc -> KnownKeyNameSource

            Just name -> return (Succeeded name)

            Nothing   -> return (Failed (MissingKnownKey3 occ)) }

   -- Just gbl_rdr_env: we have -frebindable-known-key-names on, and

   --                   here is the top-level GlobalRdrEnv

   -- Look up the /un-qualified/ known-key OccName in the GlobalRdrEnv

                            ; return (Succeeded name) }

        Failed err -> return (Failed err)

 loadKnownKeyOccMaps :: IfM lcl KnownKeyNameMaps

 loadKnownKeyOccMaps

   = do { eps <- getEps

 *                                                                      *

 ********************************************************************* -}

 loadGlobalName :: forall lcl.

                   HasDebugCallStack

                => Name

                -> Module  -- Use this for non-External Names (maybe Backpack-related?)

                -> IfM lcl (MaybeErr IfaceMessage TyThing)

 loadGlobalName name mod

   = do  { env <- getGblEnv

         ; case lookupKnotVars (if_rec_types env) mod of

                                     ; via_external }

                 }

                     ; via_external } }

   where

     via_external = do { hsc_env <- getTopEnv

            Just name -> return (Succeeded name)

            Nothing   -> return (Failed (MissingKnownKey3 occ)) }

   = case lookupKnownGRE gbl_rdr_env occ of

       Succeeded gre -> do { addUsedGRE NoDeprecationWarnings gre

                           ; let name = greName gre

 import GHC.Utils.Fingerprint(Fingerprint(..), fingerprintString, fingerprintFingerprints)

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import GHC.Data.FastString ( FastString, mkFastString, fsLit )

 import Control.Monad.Trans.State.Strict

 -- 'tcRnSrcDecls'.

 --

 -- See Note [Grand plan for Typeable] in "GHC.Tc.Instance.Typeable".

 mkTypeableBinds

   = do { dflags <- getDynFlags

        ; tcg_env <- getGblEnv

              tycons_that_need = filter tc_needs_typeable (tcg_tcs tcg_env)

                -- These tycons will need some typeable bindings

        -- Stop now if we don't need any typable bindings

        -- See (GPT8) in Note [Grand plan for Typeable]

        ; if no_typeable_binds_needed dflags this_mod tycons_that_need

                ; whenM (goptM Opt_DoCoreLinting) $

                  lintGblEnv (hsc_logger hsc_env) (hsc_dflags hsc_env) tcg_env

                ; setGblEnv tcg_env

                  $ do { -- Compare hi-boot iface (if any) with the real thing

                         -- Must be done after processing the exports

                         tcg_env <- checkHiBootIface tcg_env boot_info

                       ; -- The new type env is already available to stuff

                         -- includes the stuff in checkHiBootIface,

                         -- because the latter might add new bindings for

                         -- boot_dfuns, which may be mentioned in imported

 tcRnSrcDecls explicit_mod_hdr export_ies decls

  = do { -- Do all the declarations

       ; (tcg_env, tcl_env, lie) <- tc_rn_src_decls decls

       ------ Simplify constraints ---------

       --

                       ; ev_binds <- simplifyTop (lie `andWC` lie_main)

                       ; return (tcg_env `addEvBinds` ev_binds) }

         -- Emit Typeable bindings

       ; tcg_env <- setGblEnv tcg_env $

                    mkTypeableBinds

               -- to the previous tcg_env

             ; tcg_env' = tcg_env

                           , tcg_ev_binds  = ev_binds' `unionBags` ev_binds_mf

                           , tcg_imp_specs = imp_specs' ++ imp_specs_mf

                           , tcg_rules     = rules'     ++ rules_mf

                           , tcg_fords     = fords'     ++ fords_mf

                           , tcg_patsyns   = pat_syns'  ++ patsyns_mf } } ;

 zonkTcGblEnv :: TcGblEnv

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

       ; (tcg_env, rn_decls) <- rnTopSrcDecls first_group

                 -- rnTopSrcDecls fails if there are any errors

         -- Get TH-generated top-level declarations and make sure they don't

         -- contain any splices since we don't handle that at the moment

         --

                               AddTopDeclsUnexpectedDeclarationSplice

                         }

                       -- Rename TH-generated top-level declarations

                       -- Dump generated top-level declarations

                     ; let msg = "top-level declarations added with 'addTopDecls'"

       -- NB: set the env **before** captureTopConstraints so that error messages

       -- get reported w.r.t. the right GlobalRdrEnv. It is for this reason that

       -- the captureTopConstraints must go here, not in tcRnSrcDecls.

       ; ((tcg_env, tcl_env), lie1) <- setGblEnv tcg_env $

                                       captureTopConstraints $

                                       tcTopSrcDecls rn_decls

         ; let { type_env0 = tcg_type_env gbl_env

               ; type_env1 = extendTypeEnvWithIds type_env0 val_ids

               ; type_env2 = extendTypeEnvWithIds type_env1 dfun_ids

               }

    }}}

    ; traceTc "boot" (ppr lie); return gbl_env }

         --

         -- to (a) the type envt, and (b) the top-level bindings

         ; let boot_impedance_bds = map fst imp_prs

               impedance_binds    =  [ mkVarBind boot_id (nlHsVar id)

                                     | (boot_id, id) <- imp_prs ]

               tcg_env_w_binds

 {- Note [DFun impedance matching]

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

 to look at the mb_insts of the ModDetails in SelfBootInfo, because a

 dfun in one of those ClsInsts is gotten (in GHC.IfaceToCore.tcIfaceInst) by a

 (lazily evaluated) lookup in the if_rec_types.  We could extend the

 It is much more directly simply to extract the DFunIds from the

 md_types of the SelfBootInfo.

           -- NB: for what "things in this module" means, see

           -- Note [The interactive package] in "GHC.Runtime.Context"

                 -- Used only to initialise the interface-file

                 -- typechecker in initIfaceTcRn, so that it can see stuff

                 -- bound in this module when dealing with hi-boot recursions

                             , rdr_elt <- lookupGRE rdr_env (LookupOccName occ AllRelevantGREs) ]

     -- STEP 5: Typecheck the interfaces

     -- typecheckIfacesForMerging does two things:

     --      1. It merges the all of the ifaces together, and typechecks the

     --      resolving to the merged type_env from (1).

     -- See typecheckIfacesForMerging for more details.

     (type_env, detailss) <- initIfaceTcRn $

     let infos = zip ifaces detailss

     -- Test for cycles

     -- NB: Why do we set tcg_tcs/tcg_patsyns/tcg_type_env directly,

     -- rather than use tcExtendGlobalEnv (the normal method to add newly

     -- defined types to TcGblEnv?)  tcExtendGlobalEnv adds these

     -- we read in interfaces to tie the knot.  But *these TyThings themselves

     -- come from interface*, so that would result in deadlock.  Don't

     -- update it!

         -- Global environment

         tcExtendGlobalEnv, tcExtendTyConEnv,

         tcExtendGlobalValEnv, tcTyThBinders,

         tcLookupLocatedGlobal, tcLookupGlobal, tcLookupGlobalOnly,

         tcLookupTyCon, tcLookupClass,

 getKnownKeySource

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; if rebindable_path

          else return KKNS_FromModule }

 tcrn_wrapper :: HasDebugCallStack

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

 -}

 tcExtendGlobalEnvImplicit :: [TyThing] -> TcM r -> TcM r

   -- Do not extend tcg_tcs, tcg_patsyns etc

 tcExtendGlobalEnvImplicit things thing_inside

    = do { tcg_env <- getGblEnv

         ; setGblEnv tcg_env' thing_inside }

 tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r

  = do  { tcg_env <- getGblEnv

        ; let ge'      = extendNameEnvList (tcg_type_env tcg_env) gbl_stuff

              tcg_env' = tcg_env { tcg_type_env = ge' }

          -- when kind-check a group of type/class decls. It would

          -- in any case be wrong for an interface-file decl to end up

          -- with a TcTyCon in it!

           , tcg_default            = emptyDefaultEnv

           , tcg_default_exports    = emptyDefaultEnv

           , tcg_type_env           = emptyNameEnv

           , tcg_inst_env           = emptyInstEnv

           , tcg_fam_inst_env       = emptyFamInstEnv

           , tcg_ann_env            = emptyAnnEnv

         ; hsc_env <- getTopEnv

           -- bangs to avoid leaking the envs (#19356)

         ; let !mhome_unit = hsc_home_unit_maybe hsc_env

               -- When we are instantiating a signature,

               -- we DEFINITELY do not want to knot tie.

               is_instantiate = fromMaybe False (isHomeUnitInstantiating <$> mhome_unit)