Note [Infinite families of known-key names]

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

 Infinite families of known-key things (e.g. tuples and sums) pose a tricky

 ensure that, e.g., a reference to (,) gets assigned the right unique (if this

 doesn't sound familiar see Note [Known-key names] above).

 -}

 -- is used to initialise the name environment carried around by the renamer.

 -- This means that if we look up the name of a TyCon (or its implicit binders)

 -- that occurs in this list that name will be assigned the wired-in key we

         oldLookupKnownKeyName,

         oldLookupKnownNameInfo,

         -- * Miscellaneous

         ghcPrimExports,

         ghcPrimDeclDocs,

 -- | This list is used to ensure that when you say "Prelude.map" in your source

 -- code, or in an interface file, you get a Name with the correct known key (See

 -- Note [Known-key names] in "GHC.Builtin.Names")

 -- ToDo: rename to wiredInNames

   | debugIsOn

   , Just badNamesDoc <- knownKeyNamesOkay all_names

   = pprPanic "badAllKnownKeyNames" badNamesDoc

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

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

 oldKnownKeysMap :: UniqFM Name Name

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

 -- GHCi's ':info' command.

 --   all known-key uniques fit in this space. This is asserted by

 --   GHC.Builtin.Utils.knownKeyNamesOkay.

 --

 -- During deserialization we use lookupKnownKeyName to get from the unique back

 -- to its corresponding Name.

 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

        ; mb_res <- liftIO $ findImportedModule hsc_env kNOWN_KEY_NAMES NoPkgQual

        ; iface <- case mb_res of

            Found _ mod -> loadInterfaceWithException doc mod ImportBySystem

                     ; pprPanic "loadKnownKeyOccMap" $

                       missingInterfaceErrorDiagnostic defaultIfaceMessageOpts $

                       cannotFindModule hsc_env kNOWN_KEY_NAMES fr }

         -- We should only warn for unnecessary *user* imports, but deciding

         -- minimal imports should take generated imports into account

        ; traceRn "warnUnusedImportDecls" $

                        (vcat [ text "Uses:" <+> ppr uses

 excludeGenerated :: [LImportDecl GhcRn] -> [LImportDecl GhcRn]

 excludeGenerated = filterOut (ideclGenerated . ideclExt . unLoc)

                 -> [GlobalRdrElt]

                 -> [ImportDeclUsage]

   = map unused_decl imports

   where

     import_usage :: ImportMap

             in UnusedNames acc_ns acc_wcs acc_fs'

           | used

           = acc

           | otherwise

           = UnusedNames (acc_ns `extendNameSet` n) acc_wcs acc_fs

           where

     -- BuiltInSyntax names like (:) and []

     builtIns :: EnumSet LangExt.Extension -> [Name]

       where

         -- Tuples and sums of are not included in knownKeyName as there are infinitely many of them.

         -- See Note [Infinite families of known-key names] in GHC.Builtin.Names.

         isTyVarName, isTyConName, isDataConName,

         isValName, isVarName, isDynLinkName, isFieldName,

         isWiredInName, isWiredIn, isBuiltInSyntax, isTupleTyConName,

         isSumTyConName,

         isUnboxedTupleDataConLikeName,

         isHoleName,

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

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

 * In a very similar way, for type-class defauting GHC has built-in defaulting behaviour

   for Num, IsString, etc.   It gets hold of these classes via their known key, via

     -frebindable-known-key-names

     -fdefines-known-key-names

 Note [About the NameSorts]

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

 isExternalName    :: Name -> Bool

 isSystemName      :: Name -> Bool

 isWiredInName     :: Name -> Bool

 isWiredInName (Name {n_sort = WiredIn _ _ _}) = True

 isWiredInName _                               = False

 isWiredIn :: NamedThing thing => thing -> Bool

 isWiredIn = isWiredInName . getName

 isKnownKey :: NamedThing thing => thing -> Bool

 wiredInNameTyThing_maybe :: Name -> Maybe TyThing

 wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing

 At the same time, simple finite built-in names (`[]`, `:`, `->`) can be put in

 the OrigNameCache without any issues (they end up there because they're

 One might wonder: what's the point of having any built-in syntax in the

 OrigNameCache at all?  Good question; after all,

 {-# NOINLINE knownKeysOrigNameCache #-}

 knownKeysOrigNameCache :: OrigNameCache

 isKnownOrigName_maybe :: Module -> OccName -> Maybe Name

 isKnownOrigName_maybe = lookupOrigNameCache knownKeysOrigNameCache

 import GHC.Internal.IO.Handle.Text (hPutStrLn)

 import GHC.Internal.Prim (Array#, State#, RealWorld)

 import GHC.Internal.Types (Int, IO)

 {-# DEPRECATED runFinalizerBatch