-- 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' =

                ; 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

                       ; 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,

         ; 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,

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

 -}

 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)