basicKnownKeyTable :: [(OccName, KnownKeyNameKey)]

 basicKnownKeyTable

   = [ (mkTcOcc "Rational",     rationalTyConKey)

     , (mkTcOcc "Show",         showClassKey)

     , (mkTcOcc "Foldable",     foldableClassKey)

     , (mkTcOcc "Traversable",  traversableClassKey)

     , (mkTcOcc "Ix",           ixClassKey)

     , (mkTcOcc "Alternative",  alternativeClassKey)

     , (mkTcOcc "Eq",           eqClassKey)

     , (mkVarOcc "==",          eqClassOpKey)

     -- Numeric operations

     , (mkTcOcc "Num",               numClassKey)

     -- Class Functor

     , (mkTcOcc "Functor",     functorClassKey)

     , (mkVarOcc "fmap",       fmapClassOpKey)

     -- Class Monad, MonadFix, MonadZip

     , (mkTcOcc "Monad",        monadClassKey)

     , (mkTcOcc "IsString",    isStringClassKey)

     , (mkVarOcc "fromString", fromStringClassOpKey)

     , (mkTcOcc "HasField",   hasFieldClassKey)

     , (mkVarOcc "fromLabel", fromLabelClassOpKey)

     , (mkVarOcc "getField",  getFieldClassOpKey)

         -- Dynamic

         toDynName,

         -- Conversion functions

         ratioTyConName, ratioDataConName,

         toIntegerName, toRationalName,

         nonEmptyTyConName,

         -- List operations

         -- FFI primitive types that are not wired-in.

         stablePtrTyConName, ptrTyConName, funPtrTyConName, constPtrConName,

 *                                                                      *

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

 -}

 main_RDR_Unqual    :: RdrName

 main_RDR_Unqual = mkUnqual varName (fsLit "main")

 ge_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,

     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName

 map_RDR :: RdrName

 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR

     :: RdrName

 fmap_RDR, replace_RDR, pure_RDR, ap_RDR, liftA2_RDR, foldable_foldr_RDR,

     foldMap_RDR, null_RDR, all_RDR, traverse_RDR, mempty_RDR,

     mappend_RDR :: RdrName

 replace_RDR             = varQual_RDR gHC_INTERNAL_BASE (fsLit "<$")

 pure_RDR                = nameRdrName pureAName

 ap_RDR                  = nameRdrName apAName

 orderingTyConName, ordLTDataConName, ordEQDataConName, ordGTDataConName :: Name

 orderingTyConName = tcQual  gHC_TYPES (fsLit "Ordering") orderingTyConKey

 ordEQDataConName     = dcQual gHC_TYPES (fsLit "EQ") ordEQDataConKey

 ordGTDataConName     = dcQual gHC_TYPES (fsLit "GT") ordGTDataConKey

 unpackCStringName       = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey

 unpackCStringUtf8Name       = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey

 -- Class Monad

 thenMName, bindMName, returnMName :: Name

 thenMName          = varQual gHC_INTERNAL_BASE (fsLit ">>")     thenMClassOpKey

 -- Random GHC.Internal.Base functions

 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,

     dollarName :: Name

 dollarName        = varQual gHC_INTERNAL_BASE (fsLit "$")          dollarIdKey

 otherwiseIdName   = varQual gHC_INTERNAL_BASE (fsLit "otherwise")  otherwiseIdKey

 foldrName         = varQual gHC_INTERNAL_BASE (fsLit "foldr")      foldrIdKey

 buildName         = varQual gHC_INTERNAL_BASE (fsLit "build")      buildIdKey

 augmentName       = varQual gHC_INTERNAL_BASE (fsLit "augment")    augmentIdKey

 assertName        = varQual gHC_INTERNAL_BASE (fsLit "assert")     assertIdKey

 fromStringName    = varQual gHC_INTERNAL_DATA_STRING (fsLit "fromString") fromStringClassOpKey

 rootMainKey                   = mkPreludeMiscIdUnique 101

 runMainKey                    = mkPreludeMiscIdUnique 102

 thenIOIdKey                   = mkPreludeMiscIdUnique 103

 lazyIdKey                     = mkPreludeMiscIdUnique 104

 assertErrorIdKey              = mkPreludeMiscIdUnique 105

 rationalToFloatIdKey   = mkPreludeMiscIdUnique 132

 rationalToDoubleIdKey  = mkPreludeMiscIdUnique 133

 -- Just a placeholder for unbound variables produced by the renamer:

 unboundKey :: KnownKeyNameKey

 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,

     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,

     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,

     bindMClassOpKey, thenMClassOpKey, returnMClassOpKey, fmapClassOpKey

     :: KnownKeyNameKey

 -- Recursive do notation

 mfixIdKey :: KnownKeyNameKey

 -- MonadFail operations

 failMClassOpKey :: KnownKeyNameKey

 -- fromLabel

 fromLabelClassOpKey :: KnownKeyNameKey

 -- Arrow notation

 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,

 isListClassKey, fromListClassOpKey, fromListNClassOpKey, toListClassOpKey :: KnownKeyNameKey

 isListClassKey = mkPreludeMiscIdUnique 198

 fromListClassOpKey = mkPreludeMiscIdUnique 199

 fromListNClassOpKey = mkPreludeMiscIdUnique 500

 toListClassOpKey = mkPreludeMiscIdUnique 501

     -- Create an unzip function for the appropriate arity and element types and find "map"

     unzip_stuff' <- mkUnzipBind form from_bndrs_tys

     -- Generate the expressions to build the grouped list

     let -- First we apply the grouping function to the inner list

         dsLookupGlobal, dsLookupGlobalId, dsLookupTyCon,

         dsLookupDataCon, dsLookupConLike,

         DsMetaEnv, DsMetaVal(..), dsGetMetaEnv, dsLookupMetaEnv, dsExtendMetaEnv,

 instance MonadThings (IOEnv (Env DsGblEnv DsLclEnv)) where

     lookupThing = dsLookupGlobal

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; dsToIfL $

          do { mb_res <- lookupKnownKeyThing mb_rdr_env uniq

             ; case mb_res of

 dsLookupKnownKeyTyCon :: KnownKeyNameKey -> DsM TyCon

 dsLookupKnownKeyTyCon uniq

 dsLookupKnownKeyId :: KnownKeyNameKey -> DsM Id

 dsLookupKnownKeyId uniq

 dsLookupGlobal :: Name -> DsM TyThing

 -- Very like GHC.Tc.Utils.Env.tcLookupGlobal

 globalVar :: Name -> DsM (Core TH.Name)

 globalVar n =

   case nameModule_maybe n of

     Nothing -> globalVarLocal (getUnique n) (getOccName n)

 globalVarLocal :: Unique -> OccName -> DsM (Core TH.Name)

 globalVarLocal unique name

   = do  { MkC occ <- occNameLit name

       occ <- occNameLit occ

       repNameQ mod occ

     Orig m n -> lift $ globalVarExternal m n

 repNameS :: Core String -> MetaM (Core TH.Name)

 repNameS (MkC name) = rep2_nw mkNameSName [name]

 setRdrNameSpace (Unqual occ) ns = Unqual (setOccNameSpace ns occ)

 setRdrNameSpace (Qual m occ) ns = Qual m (setOccNameSpace ns occ)

 setRdrNameSpace (Orig m occ) ns = Orig m (setOccNameSpace ns occ)

   | Just thing <- wiredInNameTyThing_maybe n

   = setWiredInNameSpace thing ns

     -- Preserve Exact Names for wired-in things,

   | otherwise   -- This can happen when quoting and then

                 -- splicing a fixity declaration for a type

   where

     occ = setOccNameSpace ns (nameOccName n)

   | isDataConNameSpace ns

   = ty_con_data_con tc

   | isTcClsNameSpace ns

 setWiredInNameSpace (AConLike (RealDataCon dc)) ns

   | isTcClsNameSpace ns

   = data_con_ty_con dc

   | isDataConNameSpace ns

 setWiredInNameSpace thing ns

   = pprPanic "setWiredinNameSpace" (pprNameSpace ns <+> ppr thing)

 ty_con_data_con tc

   | isTupleTyCon tc

   , Just dc <- tyConSingleDataCon_maybe tc

   | tc `hasKey` listTyConKey

   | otherwise  -- See Note [setRdrNameSpace for wired-in names]

   = Unqual (setOccNameSpace srcDataName (getOccName tc))

 data_con_ty_con dc

   | let tc = dataConTyCon dc

   , isTupleTyCon tc

   | dc `hasKey` nilDataConKey

   | otherwise  -- See Note [setRdrNameSpace for wired-in names]

   = Unqual (setOccNameSpace tcClsName (getOccName dc))

 -- Does the actual looking up an Exact or Orig name, see 'ExactOrOrigResult'

 lookupExactOrOrig_base :: RdrName -> RnM ExactOrOrigResult

 lookupExactOrOrig_base rdr_name

   = cvtEither <$> lookupExactOcc_either n

   | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name

   = do { nm <- lookupOrig rdr_mod rdr_occ

        ; return $ case mb_gre of

           Left  err -> ExactOrOrigError err

           Right gre -> FoundExactOrOrig gre }

   | otherwise = return NotExactOrOrig

   where

     cvtEither (Left e)    = ExactOrOrigError e

             as_needed    = take con_arity as_RDRs

             lift_Expr    = mk_bracket finish

             con_brack :: LHsExpr GhcPs

                             [noLocA $ HsUntypedBracket noExtField

             lift_var :: RdrName -> LHsExpr (GhcPass 'Parsed)

             lift_var x   = nlHsPar (mk_lift_expr x)

             mk_lift_expr :: RdrName -> LHsExpr (GhcPass 'Parsed)

 {-

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

 newAuxBinderRdrName :: SrcSpan -> Name -> (OccName -> OccName) -> TcM RdrName

 newAuxBinderRdrName loc parent occ_fun = do

   uniq <- newUnique

 -- | @getPossibleDataCons tycon tycon_args@ returns the constructors of @tycon@

 -- whose return types match when checked against @tycon_args@.

         = addErr $ TcRnTHError $ AddTopDeclsError $ InvalidTopDecl d

       bindName :: RdrName -> TcM ()

         = do { th_topnames_var <- fmap tcg_th_topnames getGblEnv

   qAddForeignFilePath lang fp = do

     var <- fmap tcg_th_foreign_files getGblEnv

 hsTypeToArrow :: LHsType GhcPs -> HsMultAnn GhcPs

 hsTypeToArrow w = case unLoc w of

                         | n == oneDataConName -> HsLinearAnn noAnn

                         | n == manyDataConName -> HsUnannotated (EpArrow noAnn)

                      _ -> HsExplicitMult (noAnn, EpArrow noAnn) w

 knownOrigToExactRdrName :: RdrName -> RdrName

 knownOrigToExactRdrName (Orig mod occ)

   | Just name <- isKnownOrigName_maybe mod occ

 knownOrigToExactRdrName rdr = rdr

 -- Return an exact RdrName if we're dealing with built-in syntax.

 module GHC.Types.Name.Reader (

         -- * The main type

         RdrName(..),    -- Constructors exported only to GHC.Iface.Binary

         -- ** Construction

         mkRdrUnqual, mkRdrQual,

         mkUnqual, mkVarUnqual, mkQual, mkOrig,

         -- ** Destruction

         rdrNameOcc, rdrNameSpace,

         demoteRdrName, demoteRdrNameTcCls, demoteRdrNameTv,

         promoteRdrName,

         isRdrDataCon, isRdrTyVar, isRdrTc, isQual, isQual_maybe, isUnqual,

         -- ** Preserving user-written qualification

         WithUserRdr(..), noUserRdr, unLocWithUserRdr, userRdrName,

         -- we want to say \"Use Prelude.map dammit\". One of these

         -- can be created with 'mkOrig'

         -- ^ Exact name

         --

         -- We know exactly the 'Name'. This is used:

         -- Such a 'RdrName' can be created by using 'getRdrName' on a 'Name'

   deriving Data

   deriving Data

 {-

 rdrNameOcc (Qual _ occ) = occ

 rdrNameOcc (Unqual occ) = occ

 rdrNameOcc (Orig _ occ) = occ

 rdrNameSpace :: RdrName -> NameSpace

 rdrNameSpace = occNameSpace . rdrNameOcc

 getRdrName :: NamedThing thing => thing -> RdrName

 getRdrName name = nameRdrName (getName name)

 nameRdrName :: Name -> RdrName

 nameRdrName name = Exact (ExactName name)

 -- Keep the Name even for Internal names, so that the

 -- unique is still there for debug printing, particularly

 -- of Types (which are converted to IfaceTypes before printing)

 isRdrDataCon :: RdrName -> Bool

 isRdrTyVar   :: RdrName -> Bool

 isExact (Exact _) = True

 isExact _         = False

 {-

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

 -}

 instance Outputable RdrName where

     ppr (Unqual occ)   = ppr occ

     ppr (Qual mod occ) = ppr mod <> dot <> ppr occ

     ppr (Orig mod occ) = getPprStyle (\sty -> pprModulePrefix sty mod Nothing occ <> ppr occ)

     pprInfixOcc  rdr = pprInfixVar  (isSymOcc (rdrNameOcc rdr)) (ppr rdr)

     pprPrefixOcc rdr

              -- pprPrefixName has some special cases, so

              -- we delegate to them rather than reproduce them

       | otherwise = pprPrefixVar (isSymOcc (rdrNameOcc rdr)) (ppr rdr)

 instance Eq RdrName where

     (Exact n1)    == (Exact n2)    = n1==n2

         -- Convert exact to orig

     (Orig m1 o1)  == (Orig m2 o2)  = m1==m2 && o1==o2

     (Qual m1 o1)  == (Qual m2 o2)  = m1==m2 && o1==o2

   = lookupOccEnv env occ

   -- See Note [Local bindings with Exact Names]

   , name `elemNameSet` ns

   = Just name

 elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool

 elemLocalRdrEnv rdr_name (LRE { lre_env = env, lre_in_scope = ns })

   = case rdr_name of

       Qual {} -> False

       Orig {} -> False

 import GHC.Word         ( Word64 )

 import Data.Char        ( chr, ord, isPrint )

 import Language.Haskell.Syntax.Module.Name

 --

 -- These are sometimes also referred to as \"keys\" in comments in GHC.

 newtype Unique = MkUnique Word64

 data UniqueTag

   = AlphaTyVarTag