, (mkTcOcc "Bounded",      boundedClassKey)

     , (mkTcOcc "Enum",         enumClassKey)

     , (mkTcOcc "Monad",        monadClassKey)

     ]

 basicKnownKeyNames :: [Name]  -- See Note [Known-key names]

  ++ [   --  Classes.  *Must* include:

         --      classes that are grabbed by key (e.g., eqClassKey)

         --      classes in "Class.standardClassKeys" (quite a few)

         realClassName,                  -- numeric

         integralClassName,              -- numeric

         fractionalClassName,            -- numeric

 instance MonadThings (IOEnv (Env DsGblEnv DsLclEnv)) where

     lookupThing = dsLookupGlobal

 dsLookupKnownKey uniq

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; mb_rdr_env <- if rebindable_path

                  Succeeded thing -> return thing

                  Failed msg -> failIfM (pprDiagnostic msg) } }

 dsLookupKnownKeyTyCon uniq

   = tyThingTyCon <$> dsLookupKnownKey uniq

   , missingInterfaceErrorReason

   , missingInterfaceErrorDiagnostic

   , readInterfaceErrorDiagnostic

   , lookingForHerald

   , cantFindErrorX

 -}

 {-# LANGUAGE NondecreasingIndentation #-}

 {-# LANGUAGE TypeFamilies #-}

 import GHC.Iface.Rename

 import GHC.Iface.Env

 import GHC.Iface.Errors as Iface_Errors

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Types.SafeHaskell

 import GHC.Types.TypeEnv

 import GHC.Types.Unique.DSet

 import GHC.Types.SrcLoc

 import GHC.Types.TyThing

 import GHC.Types.PkgQual

                    => Maybe GlobalRdrEnv -> KnownKeyNameKey

                    -> IfM lcl Name

 lookupKnownKeyName Nothing uniq

        ; let name = lookupUFM known_key_name_map uniq

                     `orElse` pprPanic "lookupKnownKeyThing 1"

                                  (vcat [ text "unique:" <+> ppr uniq

   --                   here is the top-level GlobalRdrEnv

   -- Look up the known-key OccName in the GlobalRdrEnv

   -- If we get a unique hit, use it; if not, panic.

   = case lookupGRE gbl_rdr_env (LookupOccName occ SameNameSpace) of

        [gre] -> do { let name = greName gre

                    ; traceIf $ hang (text "lookupKnownKeyThing NoImplicitKnownKeyNames")

                                   2 (ppr name <+> ppr uniq)

                    ; return name }

   where

 loadKnownKeyOccMap :: IfM lcl KnownKeyNameMap

 loadKnownKeyOccMap

        ; mb_res <- liftIO $ findImportedModule hsc_env kNOWN_KEY_NAMES NoPkgQual

        ; iface <- case mb_res of

            Found _ mod -> loadInterfaceWithException doc mod ImportBySystem

        ; let occ_map :: KnownKeyNameMap

              occ_map = listToUFM [ (getUnique nm, nm)

        -- Record the KnownKeyOccMap in the EPS, so we will find it next time

        ; updateEps_ (\eps -> eps { eps_known_keys = Just occ_map })

        ; return occ_map } } }

   where

     doc = text "Need interface for KnonwKeyNames"

 {- *********************************************************************

 *                                                                      *

 import GHC.Parser.PostProcess ( setRdrNameSpace )

 import GHC.Builtin.Types

 import GHC.Types.Name

 import GHC.Types.Name.Set

 import GHC.Types.TyThing ( tyThingGREInfo )

 import GHC.Types.SrcLoc as SrcLoc

 import GHC.Utils.Outputable as Outputable

 import GHC.Types.Unique.FM

 import GHC.Types.Unique.DSet

 import GHC.Types.Unique.Set

            -> assert (tyConTyVars rep_tc `lengthExceeds` 0) $

               -- Generic1 has a single kind variable

               assert (cls_tys `lengthIs` 1) $

                  ; pure $ con_arg_constraints

                         $ get_gen1_constraints functorClass }

         -- Some information about where this environment came from;

         -- useful for debugging.

         if_doc :: SDoc,

         -- The type environment for the module being compiled,

         -- in case the interface refers back to it via a reference that

         -- was originally a hi-boot file.

 --

 module GHC.KnownKeyNames