A "wired-in" entity:

   * Defined in GHC.Builtin.WiredIn.*

   So GHC knows /everything/ about it.  See Note [Overview of wired-in things].

   We try hard to avoid wired-in things; it's tricky to ensure that GHC's static

 A "known-key" entity:

   * Defined in GHC.Builtin.KnownKeys

   * Its Unique and OccName are baked into GHC. Its Unique is called a KnownKey.

   * But that's all that GHC knows about it

   In particular, GHC does /not/ know in which module the entity is defined.

   Example: the `Eq` class has OccName "Eq" and unique `eqClassKey`.  It happens

   to be defined in ghc-internal:GHC.Internal.Classes, but GHC does not know that.

   See Note [Recipe for adding a known-key name] for how to add a known-key name

   to GHC. It's not hard.

 A "known-occ" entity:

   * Defined in GHC.Builtin.KnownOccs

   * Its OccName is baked into GHC -- we call it a KnownOcc

   * But that's all that GHC knows about it

   In particular, GHC does /not/ know in which module the entity is defined,

   nor its Unique.

     and then renames and typechecks them.  These bindings refer to a myriad of

     identifiers, such as `(==)`, `(>)`, `inRange`, and so on.  Again GHC does not

     need to know a statically-known unique for them, but it does need to find them

   * When desugaring, the desugarer wants to refer to a particular

     class, type, or function.  It does this via (e.g.)

        dsLookupKnownOccTyCon :: KnownOcc -> DsM TyCon

        dsLookupKnownKeyTyCon :: KnownKey -> DsM TyCon

 To implement all this, here are the moving parts.

   this is not an onerous restriction.  But see Note [Tricky known-occ cases] in

   GHC.Builtin.KnownOccs for some awkward cases.

   entities names. There is nothing special about this module except that GHC knows its

   name and can import it.

   This is a big reason for (KnownEntityInvariant): an export list cannot have two

   entities with the same OccName.

 * There are three flags that control the treatment of known entities:

     -frebindable-known-names

     -fdefines-known-names

 * DEFINING.  In the module that /defines/ a known-key name, such as

       the `Num` class in ghc-internal:GHC.Internal.Num

 * SERIALISING.

   - When we serialise a known-key name into an interface file, we mark it as such.

    So we compile GHC.Internal.Data.Foldable with

        -fexclude-known-define=toList

   because we (should) never look up a wired-in name via its key.  That is,

   `GHC.Iface.Load.lookupKnownKeyName` should never be called on the key of

   a wired-in name.

 Note [Recipe for adding a known-occ name]

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

 * In any module in `base` or `ghc-internal` (which are compiled with

   -frebindable-known-names), in which `wombat` is needed, you must ensure

 Note [Recipe for adding a known-key name]

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

   with `-fdefines-known-names`.

 * In GHC.Builtin.KnownKeys you must define a static unique

      wombatKey :: KnownKey

 {-

 (c) The GRASP/AQUA Project, Glasgow University, 1992-1998

 Nota Bene: all Names defined in here should come from the base package,

 the big-num package or (for plugins) the ghc package.

 -  An overloaded label "``#foo``" means "``fromLabel @"foo"``", rather than

    "``GHC.OverloadedLabels.fromLabel @"foo"``" (see :ref:`overloaded-labels`).

 :extension:`RebindableSyntax` implies :extension:`NoImplicitPrelude`.

 In all cases (apart from arrow notation), the static semantics should be

 {-# LANGUAGE UnboxedTuples #-}

 {-# LANGUAGE TemplateHaskellQuotes #-}

 module Data.Array.Byte (

   ByteArray(..),

   MutableByteArray(..),

 ) where

 import Prelude

 import GHC.Internal.Data.Bits ((.&.), unsafeShiftR)

 import GHC.Internal.Data.Data (mkNoRepType, Data(..))

 import GHC.Internal.Data.Typeable (Typeable)

 {-# LANGUAGE Safe #-}

 -- |

 --

 -- Module      :  Data.Bool

      ) where

 import Prelude ( Bool(..), (&&), (||), not, otherwise )

 -- $setup

 -- >>> import Prelude

 {-# LANGUAGE FlexibleInstances #-}

 {-# LANGUAGE TemplateHaskellQuotes #-}

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

 -- |

 -- Module      :  Data.Fixed

 ) where

 import Prelude

 import GHC.Internal.Data.Data

 import GHC.Internal.TypeLits (KnownNat, natVal)

 import GHC.Internal.Read

 {-# LANGUAGE Trustworthy #-}

 {-# LANGUAGE StandaloneDeriving #-}

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

 -- |

 -- Module      :  Data.Functor.Compose

   ) where

 import Prelude

 import Data.Functor.Classes

 import Control.Applicative

 import GHC.Internal.Data.Coerce (coerce)

 {-# LANGUAGE Safe #-}

 {-# LANGUAGE StandaloneDeriving #-}

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

 -- |

 -- Module      :  Data.Functor.Product

   ) where

 import Prelude

 import Control.Applicative

 import GHC.Internal.Control.Monad (MonadPlus(..))

 import GHC.Internal.Control.Monad.Fix (MonadFix(..))

 {-# LANGUAGE Safe #-}

 {-# LANGUAGE StandaloneDeriving #-}

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

 -- |

 -- Module      :  Data.Functor.Sum

   ) where

 import Prelude

 import Control.Applicative ((<|>))

 import GHC.Internal.Data.Data (Data)

 import Data.Functor.Classes

     type (~)

   ) where

 import GHC.Internal.Control.Monad

 import GHC.Internal.System.IO

 import GHC.Internal.System.IO.Error

 {-# LANGUAGE Safe #-}

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

 -- |

 -- Module      :  System.Console.GetOpt

 ) where

 import Prelude

 import GHC.Internal.Data.List ( isPrefixOf, find )

 -- |What to do with options following non-options

   For modules high up in the hierarchy of `base`, a convenient way to

   do this is to say

   For modules not so high up, you can say

   though you may also need GHC.Internal.Num when numerics are concerned.

   For `ghc-internal` modules below GHC.Internal.Base we have to be more selective.

        ( IsLabel(..)

        ) where

 class IsLabel (x :: Symbol) a where

   fromLabel :: a

         -- don't need the Prelude here so we add NoImplicitPrelude.

      ++ "{-# OPTIONS_GHC -Wno-deprecations -O0 -fno-do-eta-reduction #-}\n"

         -- Very important OPTIONS_GHC!  See Note [OPTIONS_GHC in GHC.PrimopWrappers]

      ++ "module GHC.Internal.PrimopWrappers where\n"

      ++ "import qualified GHC.Internal.Prim\n"

      ++ "import GHC.Internal.Tuple ()\n"

      ++ "import GHC.Internal.Prim (" ++ types ++ ")\n"

      ++ unlines (concatMap mk_wrapper wrappers)