import GHC.Types.Name.Occurrence

 import GHC.Types.Name.Reader

 import GHC.Types.Unique

 import GHC.Builtin.Uniques

 import GHC.Types.Name

 import GHC.Types.SrcLoc

 import GHC.Data.FastString

 {-

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

 \subsection{Local Names}

 *                                                                      *

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

 wired in ones are defined in GHC.Builtin.Types etc.

 -}

 basicKnownKeyTable :: [(OccName, KnownKeyNameKey)]

 basicKnownKeyTable

   = [ (mkTcOcc "Rational",     rationalTyConKey)

 clsQual  modu str unique = mk_known_key_name clsName modu str unique

 dcQual   modu str unique = mk_known_key_name dataName modu str unique

 {-

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

 import GHC.Prelude ()

 import GHC.Unit.Types

 import GHC.Types.Name.Occurrence( OccName, tcName, clsName, dataName, varName, fieldName )

 import GHC.Types.Name.Reader( RdrName, nameRdrName )

 import GHC.Types.Unique ( Unique )

 --

 module GHC.Builtin.Utils (

         -- * Known-key names

         -- ** Internal use

         -- | 'knownKeyNames' is exported to seed the original name cache only;

         -- if you find yourself wanting to look at it you might consider using

         -- 'lookupKnownKeyName' or 'isKnownKeyName'.

         knownKeyNames,

         -- * Miscellaneous

         wiredInIds, ghcPrimIds,

 import GHC.Builtin.Types

 import GHC.Builtin.Types.Literals ( typeNatTyCons )

 import GHC.Builtin.Types.Prim

 import GHC.Builtin.Names

 import GHC.Core.ConLike ( ConLike(..) )

                            text ": " <>

                            brackets (pprWithCommas (ppr . nameOccName) ns)

 -- | Given a 'Unique' lookup its associated 'Name' if it corresponds to a

 -- known-key thing.

 -- TODO: remove this once all knownkey names come from providers

 -- | Is a 'Name' known-key?

 -- | Maps 'Unique's to known-key names.

 --

 -- The type is @UniqFM Name Name@ to denote that the 'Unique's used

 -- in the domain are 'Unique's associated with 'Name's (as opposed

 -- to some other namespace of 'Unique's).

 -- | Given a 'Unique' lookup any associated arbitrary SDoc's to be displayed by

 -- GHCi's ':info' command.

     -- If we do find a doc, we add comment delimiters to make the output

     -- of ':info' valid Haskell.

     Nothing  -> empty

 import GHC.Prelude

 import GHC.Utils.Panic

 import GHC.Utils.Binary as Binary

 import GHC.Utils.Outputable

                bin_symtab_map = symtab_map_ref,

                bin_symtab_next = symtab_next }

         bh name

   , let (c, u) = unpkUniqueGrimly (nameUnique name) -- INVARIANT: (ord c) fits in 8 bits

   = -- assert (u < 2^(22 :: Int))

     put_ bh (0x80000000

           ix  = fromIntegral i .&. 0x003FFFFF

           u   = mkUniqueGrimilyWithTag tag ix

         in

                       Nothing -> pprPanic "getSymtabName:unknown known-key unique"

                                           (ppr i $$ ppr u $$ char tag $$ ppr ix)

                       Just n  -> n

         -- Importing one thing

         importDecl,

         checkWiredInTyCon, ifCheckWiredInThing,

         -- RnM/TcM functions

         loadModuleInterface, loadModuleInterfaces,

 import GHC.Iface.Env

 import GHC.Iface.Errors as Iface_Errors

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

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

 lookupKnownKeyThing :: HasDebugCallStack

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

   = do { known_key_name_map <- loadKnownKeyOccMap

        ; let name = lookupUFM known_key_name_map uniq

                     `orElse` pprPanic "lookupKnownKeyThing 1"

                                        , text "occ-map" <+> ppr known_key_name_map ])

        ; traceIf $ hang (text "lookupKnownKeyThing ImplicitKnownKeyNames")

                       2 (ppr name <+> ppr uniq)

   -- 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)

   where

      occ = lookupUFM knownKeyUniqMap uniq

            `orElse` pprPanic "lookupKnownKeyThing 2"

        ; thing  <- tcRnLookupName' name

        ; fixity <- lookupFixityRn name

        ; (cls_insts, fam_insts) <- lookupInsts thing

        ; return (thing, fixity, cls_insts, fam_insts, info) }

         mkFCallName,

         mkExternalName, mkWiredInName, mkKnownKeyName,

         -- ** Manipulating and deconstructing 'Name's

         nameUnique, setNameUnique,

         nameOccName, nameNameSpace, nameModule, nameModule_maybe, extNamePieces,

        eqClassKey = mkPreludeClassUnique 3

 * All the known-key names are gathered in one table:

 Note [About the NameSorts]

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

 -- See if a thing has a particular known key

 hasKnownKey = hasKey

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

 *                                                                      *

 {-# LANGUAGE UnboxedTuples #-}

 {-# LANGUAGE Unsafe #-}

 -- -Wno-orphans is needed for things like:

 -- Orphan rule: "x# -# x#" ALWAYS forall x# :: Int# -# x# x# = 0

 {-# OPTIONS_GHC -Wno-orphans #-}

 import GHC.Internal.TH.Syntax

 import GHC.Internal.TH.Monad

 import GHC.Internal.Data.Either

 import GHC.Internal.Base (String, Void, map, mapM, ord, return, (.))