tcLookupKnownOccTyCon :: KnownOcc -> TcM TyCon

        dsLookupKnownOccTyCon :: KnownOcc -> DsM TyCon

   There are then two cases, covered in the following sections.

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

   In normal client code, suppose the desugarer calls

      dsLookupKnownKeyTyCon rationalTyConKey

   Now it can simply look up `rationalTyConKey` in the `eps_known_keys`.  Easy!

   See `GHC.Iface.Load.lookupKnownKeyThing` and `lookupKnownOccThing`.

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

   We can't follow the above plan when compiling modules in `base` or `ghc-internal` because

   GHC.Essentials has not yet been compiled!  Instead, we use (roughly) whatever is in

     * We switch on -frebindable-known-names

     * Suppose we are looking up the known-occ entity "wombat".   The key function is

       `lookupKnownGRE`:

   Alternative: export all wired-in entities from GHC.Essentials.  But that

   would simply bloat the interface for no good reason.

 Note [Recipe for adding a known-occ name]

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

 To make `wombat` into a known-occ name, you do the following:

 *                                                                      *

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

 dsGetKnownKeySource

   = do { rebindable_path <- goptM Opt_RebindableKnownNames

        ; if rebindable_path

          then do { env <- getGblEnv

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

 -- Lookups for known-occ things

         loadGlobalName,

         -- Known-occ things

         lookupKnownKeyThing, lookupKnownKeyName,

         lookupKnownOccThing, lookupKnownOccName,

         loadKnownKeyOccMaps, lookupKnownGRE,

 *                                                                      *

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

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

        -- ^ Look up the known-occ name in the export list of GHC.Essentials

        -- This is the "normal path", and happens when -frebindable-known-names

        -- is /not/ set

 lookupKnownKeyThing :: HasDebugCallStack

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

 lookupKnownKeyThing key kk_ns

   = do { mb_name <- lookupKnownKeyName key kk_ns

              Succeeded name -> lookupKnownName kk_ns name }

 lookupKnownKeyName :: HasDebugCallStack

                    -> IfM lcl (MaybeErr IfaceMessage Name)

   = do { (kk_map, _) <- loadKnownKeyOccMaps

        ; return $ lookupKnownKeysMap kk_map key }

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

   --                   here is the top-level GlobalRdrEnv

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

     gres = lookupGRE rdr_env (LookupOccName occ SameNameSpace)

 lookupKnownOccThing :: HasDebugCallStack

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

 lookupKnownOccThing occ kk_ns

   = do { mb_name <- lookupKnownOccName occ kk_ns

              Succeeded name -> lookupKnownName kk_ns name }

 lookupKnownOccName :: HasDebugCallStack

                    -> IfM lcl (MaybeErr IfaceMessage Name)

   = do { (_, occ_map) <- loadKnownKeyOccMaps

        ; case lookupOccEnv occ_map occ of

            Just name -> return (Succeeded name)

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

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

   --                   here is the top-level GlobalRdrEnv

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

        Failed err -> return (Failed err)

 lookupKnownName :: HasDebugCallStack

                 -> IfM lcl (MaybeErr IfaceMessage TyThing)

 -- Go from a known Name to its TyThing

 -- in case it is defined right here in this module rather than imported

 lookupKnownName kk_ns name

   = case kk_ns of

          | name_mod == this_mod

       _ -> loadGlobalName name name_mod

   where

   -- rather than the current module so we need this special case.

   -- See some similar logic in `GHC.Rename.Env`.

   | Just rOOT_MAIN == nameModule_maybe gbl_name

         Failed err          -> failIfM (pprDiagnostic err)

         Succeeded ioTyThing -> do

           ATyCon ioTyCon <- pure ioTyThing

            Succeeded name -> return name }

 lookup_known_occ :: HasDebugCallStack

                    -> RnM (MaybeErr IfaceMessage Name)

   = do { (_, occ_map) <- initIfaceTcRn loadKnownKeyOccMaps

        ; case lookupOccEnv occ_map occ of

            Just name -> return (Succeeded name)

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

       Succeeded gre -> do { addUsedGRE NoDeprecationWarnings gre

                           ; let name = greName gre

                           ; traceIf $ hang (text "lookupKnownKeyOcc NoImplicitKnownKeyNames")

 import GHC.Iface.Env( newGlobalBinder )

 import GHC.Builtin.Modules( gHC_TYPES, gHC_PRIM )

 import GHC.Builtin.KnownOccs

 import GHC.Builtin.WiredIn.Prim ( primTyCons )

 import GHC.Builtin.WiredIn.Types

 -- | We generate `KindRep`s for a few common kinds, so that they

 -- can be reused across modules.

 -- These definitions are generated in `ghc-prim:GHC.Types`.

 builtInKindReps =

     ]

   where

     star = liftedTypeKind

 initialKindRepEnv :: TcRn KindRepEnv

 initialKindRepEnv = foldlM add_kind_rep emptyTypeMap builtInKindReps

   where

         return $! extendTypeMap acc k (id, Nothing)

         -- The TypeMap looks through type synonyms

                       ; return (tcg_env `addEvBinds` ev_binds) }

         -- Emit Typeable bindings

                    mkTypeableBinds

       ; traceTc "Tc9" empty

         tcl_arrow_ctxt :: ArrowCtxt,       -- Arrow-notation context

         tcl_env  :: TcTypeEnv    -- The local type environment:

     }

 getLclEnvThLevel :: TcLclEnv -> ThLevel

   = do { t <- tcLookupTyCon tc_name

        ; return (mkTyConTy t) }

 -- Used by both renamer and typechecker and renamer

 getKnownKeySource

   = do { rebindable_path <- goptM Opt_RebindableKnownNames

        ; if rebindable_path

 tcrn_wrapper :: HasDebugCallStack

 tcrn_wrapper do_the_lookup

   = do { kk_source <- getKnownKeySource

        ; mb_res <- initIfaceTcRn (do_the_lookup kk_source)