-        wiredInNames, wiredInIds, ghcPrimIds, allKnownOccs,

-import GHC.Builtin.TH ( templateHaskellNames, thKnownOccs )

-import GHC.Builtin.KnownOccs( knownOccs, knownOccRdrNames )

-import GHC.Types.Name.Reader( rdrNameOcc )

-allKnownOccs :: OccSet

--- Used only for

---  (a) sanity checks

---  (b) suppressing unused-import warnings in `ghc-internal` and `base`

-allKnownOccs

-  = mkOccSet thKnownOccs `unionOccSets`

-    mkOccSet knownOccs   `unionOccSets`

-    mkOccSet (map rdrNameOcc knownOccRdrNames)

-

-

-             -- ToDo: get rid of these

-             , basicKnownKeyNames

-             , templateHaskellNames

-Note [Known-key names]   <---- LEGACY VERSION

-~~~~~~~~~~~~~~~~~~~~~~

-It is *very* important that the compiler gives wired-in things and

-things with "known-key" names the correct Uniques wherever they

-occur. We have to be careful about this in exactly two places:

-

-  1. When we parse some source code, renaming the AST better yield an

-     AST whose Names have the correct uniques

-

-  2. When we read an interface file, the read-in gubbins better have

-     the right uniques

-

-This is accomplished through a combination of mechanisms:

-

-  1. When parsing source code, the RdrName-decorated AST has some

-     RdrNames which are Exact. These are wired-in RdrNames where

-     we could directly tell from the parsed syntax what Name to

-     use. For example, when we parse a [] in a type and ListTuplePuns

-     are enabled, we can just insert (Exact listTyConName :: RdrName).

-

-     This is just an optimisation: it would be equally valid to output

-     Orig RdrNames that correctly record the module (and package) that

-     we expect the final Name to come from. The name would be looked up

-     in the OrigNameCache (see point 3).

-

-  2. The knownKeyNames (which consist of the basicKnownKeyNames from

-     the module, and those names reachable via the wired-in stuff from

-     GHC.Builtin.Types) are used to initialise the "OrigNameCache" in

-     GHC.Iface.Env.  This initialization ensures that when the type checker

-     or renamer (both of which use GHC.Iface.Env) look up an original name

-     (i.e. a pair of a Module and an OccName) for a known-key name

-     they get the correct Unique.

-

-     This is the most important mechanism for ensuring that known-key

-     stuff gets the right Unique, and is why it is so important to

-     place your known-key names in the appropriate lists.

-

-  3. For "infinite families" of known-key names (i.e. tuples and sums), we

-     have to be extra careful. Because there are an infinite number of

-     these things, we cannot add them to the list of known-key names

-     used to initialise the OrigNameCache. Instead, lookupOrigNameCache pretends

-     that these names are in the cache by using isInfiniteFamilyOrigName_maybe

-     before the actual lookup.

-     See Note [Infinite families of known-key names] for details.

-

-

-import GHC.Builtin.TH( thKnownKeyTable )

-  = thKnownKeyTable ++

-    [ (mkTcOcc "IO", ioTyConKey)

-    , (mkTcOcc "Functor",     functorClassKey)

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

-basicKnownKeyNames

- = [

-    ]

-

-knownOccs :: [KnownOcc]

--- Used only for sanity-checks

--- Sadly incomplete .. is it worth it?  See fromEnum_REDR etc....

-knownOccs

-  = [ composeIdOcc

-    , rationalTyConOcc

-

-    -- Enum class ops

-    , enumFromClassOpOcc, enumFromThenClassOpOcc

-    , enumFromToClassOpOcc, enumFromThenToClassOpOcc

-

-    -- Static

-    , fromStaticPtrClassOpOcc

-

-    -- Typeable stuff

-    , someTypeRepTyConOcc, someTypeRepDataConOcc, mkTrConOcc, mkTrAppCheckedOcc

-    , mkTrFunOcc, typeRepIdOcc, typeNatTypeRepOcc, typeSymbolTypeRepOcc

-    , typeCharTypeRepOcc, typeLitSymbolDataConOcc, typeLitNatDataConOcc

-    , typeLitCharDataConOcc

-    , trModuleTyConOcc, trModuleDataConOcc, trNameSDataConOcc, trTyConTyConOcc

-    , trTyConDataConOcc, kindRepTyConOcc, kindRepTyConAppDataConOcc, kindRepVarDataConOcc

-    , kindRepAppDataConOcc, kindRepFunDataConOcc, kindRepTypeDataConOcc

-    , kindRepTypeLitSDataConOcc

-    ]

-

-knownOccRdrNames :: [RdrName]

-knownOccRdrNames

-  = [ toDyn_RDR, compose_RDR

-    , appE_RDR, lift_RDR, liftTyped_RDR

-    , enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR

-    , fromEnum_RDR, toEnum_RDR, toEnumError_RDR, succError_RDR

-    , predError_RDR, enumIntToWord_RDR, succ_RDR, pred_RDR

-    , minBound_RDR, maxBound_RDR

-    , times_RDR, plus_RDR, and_RDR, not_RDR, range_RDR, inRange_RDR, index_RDR

-    , unsafeIndex_RDR, unsafeRangeSize_RDR

-    ]

-

-import GHC.Types.Name( Name, KnownOcc, KnownKey, mk_known_key_name )

-thKnownKeyTable :: [(OccName, KnownKey)]

-thKnownKeyTable

-  = [ (liftClassOcc, liftClassKey)

-    ]

-

-thKnownOccs :: [KnownOcc]

-thKnownOccs

-  = [ qTyConOcc, nameTyConOcc, fieldExpTyConOcc, patTyConOcc

-    , fieldPatTyConOcc, expTyConOcc, decTyConOcc, typeTyConOcc

-    , matchTyConOcc, clauseTyConOcc, funDepTyConOcc, predTyConOcc

-    , codeTyConOcc, injAnnTyConOcc, overlapTyConOcc, decsTyConOcc

-    , modNameTyConOcc, quasiQuoterTyConOcc

-    , liftIdOcc, unsafeCodeCoerceOcc

-    , charLOcc, stringLOcc, integerLOcc, intPrimLOcc, wordPrimLOcc

-    , floatPrimLOcc, doublePrimLOcc, rationalLOcc, stringPrimLOcc

-    , charPrimLOcc

-    , litPOcc, varPOcc, tupPOcc, unboxedTupPOcc, unboxedSumPOcc, conPOcc

-    , infixPOcc, tildePOcc, bangPOcc, asPOcc, wildPOcc, recPOcc, listPOcc

-    , sigPOcc, viewPOcc, typePOcc, invisPOcc, orPOcc

-    , matchOcc, fieldPatOcc, clauseOcc

-    , varEOcc, conEOcc, litEOcc, appEOcc, appTypeEOcc, infixEOcc, infixAppOcc

-    , sectionLOcc, sectionROcc, lamEOcc, lamCaseEOcc, lamCasesEOcc, tupEOcc

-    , unboxedTupEOcc, unboxedSumEOcc, condEOcc, multiIfEOcc, letEOcc

-    , caseEOcc, doEOcc, mdoEOcc, compEOcc, staticEOcc, unboundVarEOcc

-    , labelEOcc, implicitParamVarEOcc, getFieldEOcc, projectionEOcc, typeEOcc

-    , forallEOcc, forallVisEOcc, constrainedEOcc

-    , fieldExpOcc

-    , funDOcc, valDOcc, dataDOcc, newtypeDOcc, typeDataDOcc, tySynDOcc, classDOcc

-    , instanceWithOverlapDOcc, sigDOcc, kiSigDOcc, forImpDOcc, pragInlDOcc

-    , pragSpecDOcc, pragSpecInlDOcc, pragSpecEDOcc, pragSpecInlEDOcc

-    , pragSpecInstDOcc, pragRuleDOcc

-    , pragAnnDOcc, pragSCCFunDOcc, pragSCCFunNamedDOcc

-    , standaloneDerivWithStrategyDOcc, defaultSigDOcc, defaultDOcc

-    , dataInstDOcc, newtypeInstDOcc, tySynInstDOcc, dataFamilyDOcc

-    , openTypeFamilyDOcc, closedTypeFamilyDOcc, infixLWithSpecDOcc

-    , infixRWithSpecDOcc, infixNWithSpecDOcc, roleAnnotDOcc, patSynDOcc

-    , patSynSigDOcc, pragCompleteDOcc, implicitParamBindDOcc, pragOpaqueDOcc

-    , patQTyConOcc, expQTyConOcc, stmtTyConOcc, conTyConOcc, bangTypeTyConOcc

-    , varBangTypeTyConOcc, typeQTyConOcc, decsQTyConOcc, ruleBndrTyConOcc

-    , tySynEqnTyConOcc, roleTyConOcc, derivClauseTyConOcc, kindTyConOcc

-    , tyVarBndrUnitTyConOcc, tyVarBndrSpecTyConOcc, tyVarBndrVisTyConOcc

-    , derivStrategyTyConOcc

-    , guardedBOcc, normalBOcc

-    , normalGEOcc, patGEOcc

-    , bindSOcc, letSOcc, noBindSOcc, parSOcc, recSOcc

-    ]

-

-templateHaskellNames :: [Name]

--- The names that are implicitly mentioned by ``bracket''

--- Should stay in sync with the import list of GHC.HsToCore.Quote

-

-templateHaskellNames = [

-    newNameName,

-    mkNameName, mkNameG_vName, mkNameG_dName, mkNameG_tcName, mkNameG_fldName,

-    mkNameLName,

-    mkNameSName, mkNameQName,

-    mkModNameName,

-    unTypeName, unTypeCodeName,

-

-    -- Cxt

-    cxtName,

-

-    -- SourceUnpackedness

-    noSourceUnpackednessName, sourceNoUnpackName, sourceUnpackName,

-    -- SourceStrictness

-    noSourceStrictnessName, sourceLazyName, sourceStrictName,

-    -- Con

-    normalCName, recCName, infixCName, forallCName, gadtCName, recGadtCName,

-    -- Bang

-    bangName,

-    -- BangType

-    bangTypeName,

-    -- VarBangType

-    varBangTypeName,

-    -- PatSynDir (for pattern synonyms)

-    unidirPatSynName, implBidirPatSynName, explBidirPatSynName,

-    -- PatSynArgs (for pattern synonyms)

-    prefixPatSynName, infixPatSynName, recordPatSynName,

-    -- Type

-    forallTName, forallVisTName, varTName, conTName, infixTName, appTName,

-    appKindTName, equalityTName, tupleTName, unboxedTupleTName,

-    unboxedSumTName, arrowTName, mulArrowTName, listTName, sigTName, litTName,

-    promotedTName, promotedTupleTName, promotedNilTName, promotedConsTName,

-    wildCardTName, implicitParamTName,

-    -- TyLit

-    numTyLitName, strTyLitName, charTyLitName,

-    -- TyVarBndr

-    plainTVName, kindedTVName,

-    plainInvisTVName, kindedInvisTVName,

-    plainBndrTVName, kindedBndrTVName,

-    -- Specificity

-    specifiedSpecName, inferredSpecName,

-    -- Visibility

-    bndrReqName, bndrInvisName,

-    -- Role

-    nominalRName, representationalRName, phantomRName, inferRName,

-    -- Kind

-    starKName, constraintKName,

-    -- FamilyResultSig

-    noSigName, kindSigName, tyVarSigName,

-    -- InjectivityAnn

-    injectivityAnnName,

-    -- Callconv

-    cCallName, stdCallName, cApiCallName, primCallName, javaScriptCallName,

-    -- Safety

-    unsafeName,

-    safeName,

-    interruptibleName,

-    -- Inline

-    noInlineDataConName, inlineDataConName, inlinableDataConName,

-    -- RuleMatch

-    conLikeDataConName, funLikeDataConName,

-    -- Phases

-    allPhasesDataConName, fromPhaseDataConName, beforePhaseDataConName,

-    -- Overlap

-    overlappableDataConName, overlappingDataConName, overlapsDataConName,

-    incoherentDataConName,

-    -- NamespaceSpecifier

-    noNamespaceSpecifierDataConName, typeNamespaceSpecifierDataConName,

-    dataNamespaceSpecifierDataConName,

-    -- DerivStrategy

-    stockStrategyName, anyclassStrategyName,

-    newtypeStrategyName, viaStrategyName,

-    -- RuleBndr

-    ruleVarName, typedRuleVarName,

-    -- FunDep

-    funDepName,

-    -- TySynEqn

-    tySynEqnName,

-    -- AnnTarget

-    valueAnnotationName, typeAnnotationName, moduleAnnotationName,

-    -- DerivClause

-    derivClauseName,

-

-    -- Quasiquoting

-    quoteDecName, quoteTypeName, quoteExpName, quotePatName]

-

-liftClassOcc, quoteClassOcc :: KnownOcc

-liftClassOcc  = mkTcOcc "Lift"

-quoteClassKey :: Unique

-quoteClassKey = mkPreludeClassUnique 201

-

-  -- Look for the magic names in scope. If found, check if this is the defining

-  -- module. Otherwise, it definitely isn't the defining module.

-  let

-    kes = KES_InScope { ke_mod = ds_mod env

-                      , ke_rdr_env = ds_gbl_rdr_env env

-                      , ke_gbl_type_env = ds_type_env env

-                      , ke_lcl_type_env = emptyNameEnv }

-    definesMagicName magicKey = do

-      mb_res <- lookupKnownKeyName magicKey kes

-      case mb_res of

-        Succeeded name -> return (nameModule name == this_mod)

-        Failed _ -> return False

-  dfns_magic <- setEnvs (ds_if_env env) $

-    mapM (definesMagicName . fst) magicDefns

-  pure $ any id dfns_magic

-        ; if this_unit == ghcInternalUnit

-Certain libraries (ghc-prim, base, etc.) are known to the compiler and to the

-RTS as they provide some basic primitives.  Hence UnitIds of wired-in libraries

-are fixed. Instead of letting Cabal choose the UnitId for these libraries, their

-.cabal file uses the following stanza to force it to a specific value:

-   ghc-options: -this-unit-id ghc-prim    -- taken from ghc-prim.cabal

-The RTS also uses entities of wired-in units by directly referring to symbols

-such as "base_GHCziIOziException_heapOverflow_closure" where the prefix is

-the UnitId of "base" unit.

-ghcInternalUnitId = UnitId (fsLit "ghc-internal")

-module GHC.Internal.Classes.IP( IP(..)) where