{- (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 -}{-# LANGUAGE CPP #-}-- | The @PrelInfo@ interface to the compiler's prelude knowledge.---- This module serves as the central gathering point for names which the-- compiler knows something about. This includes functions for,---- * discerning whether a 'Name' is known-key---- * given a 'Unique', looking up its corresponding known-key 'Name'---- See Note [Known-key names] and Note [About wired-in things] for information-- about the two types of prelude things in GHC.--modulePrelInfo(-- * Known-key namesisKnownKeyName ,lookupKnownKeyName ,lookupKnownNameInfo ,-- ** 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 ,-- * MiscellaneouswiredInIds,ghcPrimIds,primOpRules,builtinRules,ghcPrimExports ,primOpId ,-- * Random other thingsmaybeCharLikeCon ,maybeIntLikeCon ,-- * Class categoriesisNumericClass ,isStandardClass )where#include "HsVersions.h" importGhcPreludeimportKnownUniquesimportUnique(isValidKnownKeyUnique)importConLike(ConLike(..))importTHNames (templateHaskellNames )importPrelNamesimportPrelRulesimportAvailimportPrimOpimportDataConimportIdimportNameimportNameEnvimportMkIdimportOutputableimportTysPrimimportTysWiredInimportHscTypesimportClassimportTyConimportUniqFMimportUtilimportTcTypeNats (typeNatTyCons )importControl.Applicative((<|>))importData.List(intercalate)importData.ArrayimportData.Maybe{- ************************************************************************ * * \subsection[builtinNameInfo]{Lookup built-in names} * * ************************************************************************ Note [About wired-in things] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * Wired-in things are Ids\/TyCons that are completely known to the compiler. They are global values in GHC, (e.g. listTyCon :: TyCon). * A wired in Name contains the thing itself inside the Name: see Name.wiredInNameTyThing_maybe (E.g. listTyConName contains listTyCon. * The name cache is initialised with (the names of) all wired-in things (except tuples and sums; see Note [Known-]) * The type environment itself contains no wired in things. The type checker sees if the Name is wired in before looking up the name in the type environment. * MkIface prunes out wired-in things before putting them in an interface file. So interface files never contain wired-in things. -}-- | 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 PrelNames)knownKeyNames::[Name]knownKeyNames |debugIsOn,JustbadNamesStr <-knownKeyNamesOkay all_names =panic("badAllKnownKeyNames:\n"++badNamesStr )-- NB: We can't use ppr here, because this is sometimes evaluated in a-- context where there are no DynFlags available, leading to a cryptic-- "<<details unavailable>>" error. (This seems to happen only in the-- stage 2 compiler, for reasons I [Richard] have no clue of.)|otherwise=all_names whereall_names =concat[wired_tycon_kk_names funTyCon,concatMapwired_tycon_kk_names primTyCons,concatMapwired_tycon_kk_names wiredInTyCons-- Does not include tuples,concatMapwired_tycon_kk_names typeNatTyCons ,mapidNamewiredInIds,map(idName.primOpId )allThePrimOps,basicKnownKeyNames,templateHaskellNames ]-- All of the names associated with a wired-in TyCon.-- This includes the TyCon itself, its DataCons and promoted TyCons.wired_tycon_kk_names::TyCon->[Name]wired_tycon_kk_names tc =tyConNametc :(rep_names tc ++implicits )whereimplicits =concatMapthing_kk_names (implicitTyConThingstc )wired_datacon_kk_names::DataCon->[Name]wired_datacon_kk_names dc =dataConNamedc :rep_names (promoteDataCondc )thing_kk_names::TyThing->[Name]thing_kk_names (ATyContc )=wired_tycon_kk_names tc thing_kk_names(AConLike(RealDataCondc ))=wired_datacon_kk_names dc thing_kk_namesthing =[getNamething ]-- The TyConRepName for a known-key TyCon has a known key,-- but isn't itself an implicit thing. Yurgh.-- NB: if any of the wired-in TyCons had record fields, the record-- field names would be in a similar situation. Ditto class ops.-- But it happens that there aren't anyrep_names tc =casetyConRepName_maybetc ofJustn ->[n ]Nothing->[]-- | Check the known-key names list of consistency.knownKeyNamesOkay::[Name]->MaybeStringknownKeyNamesOkay all_names |ns @(_:_)<-filter(not.isValidKnownKeyUnique.getUnique)all_names =Just$" Out-of-range known-key uniques: ["++intercalate", "(map(occNameString.nameOccName)ns )++"]"|nullbadNamesPairs =Nothing|otherwise=JustbadNamesStr wherenamesEnv =foldl'(\m n ->extendNameEnv_Acc(:)singletonm n n )emptyUFMall_names badNamesEnv =filterNameEnv(\ns ->ns `lengthExceeds`1)namesEnv badNamesPairs =nonDetUFMToListbadNamesEnv -- It's OK to use nonDetUFMToList here because the ordering only affects-- the message when we get a panicbadNamesStrs =mappairToStr badNamesPairs badNamesStr =unlinesbadNamesStrs pairToStr (uniq ,ns )=" "++showuniq ++": ["++intercalate", "(map(occNameString.nameOccName)ns )++"]"-- | Given a 'Unique' lookup its associated 'Name' if it corresponds to a-- known-key thing.lookupKnownKeyName::Unique->MaybeNamelookupKnownKeyName u =knownUniqueNameu <|>lookupUFMknownKeysMap u -- | Is a 'Name' known-key?isKnownKeyName::Name->BoolisKnownKeyName n =isJust(knownUniqueName$nameUniquen )||elemUFMn knownKeysMap knownKeysMap::UniqFMNameknownKeysMap =listToUFM[(nameUniquen ,n )|n <-knownKeyNames ]-- | Given a 'Unique' lookup any associated arbitrary SDoc's to be displayed by-- GHCi's ':info' command.lookupKnownNameInfo::Name->SDoclookupKnownNameInfo name =caselookupNameEnvknownNamesInfo name of-- If we do find a doc, we add comment delimeters to make the output-- of ':info' valid Haskell.Nothing->emptyJustdoc ->vcat[text"{-",doc ,text"-}"]-- A map from Uniques to SDocs, used in GHCi's ':info' command. (#12390)knownNamesInfo::NameEnvSDocknownNamesInfo =unitNameEnvcoercibleTyConName$vcat[text"Coercible is a special constraint with custom solving rules.",text"It is not a class.",text"Please see section 9.14.4 of the user's guide for details."]{- We let a lot of "non-standard" values be visible, so that we can make sense of them in interface pragmas. It's cool, though they all have "non-standard" names, so they won't get past the parser in user code. ************************************************************************ * * PrimOpIds * * ************************************************************************ -}primOpIds::ArrayIntId-- A cache of the PrimOp Ids, indexed by PrimOp tagprimOpIds =array(1,maxPrimOpTag)[(primOpTagop ,mkPrimOpIdop )|op <-allThePrimOps]primOpId::PrimOp->IdprimOpId op =primOpIds !primOpTagop {- ************************************************************************ * * Export lists for pseudo-modules (GHC.Prim) * * ************************************************************************ GHC.Prim "exports" all the primops and primitive types, some wired-in Ids. -}ghcPrimExports::[IfaceExport]ghcPrimExports =map(avail.idName)ghcPrimIds++map(avail.idName.primOpId )allThePrimOps++[AvailTCn [n ][]|tc <-funTyCon:exposedPrimTyCons,letn =tyConNametc ]{- ************************************************************************ * * Built-in keys * * ************************************************************************ ToDo: make it do the ``like'' part properly (as in 0.26 and before). -}maybeCharLikeCon,maybeIntLikeCon::DataCon->BoolmaybeCharLikeCon con =con `hasKey`charDataConKeymaybeIntLikeCon con =con `hasKey`intDataConKey{- ************************************************************************ * * Class predicates * * ************************************************************************ -}isNumericClass,isStandardClass::Class->BoolisNumericClass clas =classKeyclas `is_elem `numericClassKeysisStandardClass clas =classKeyclas `is_elem `standardClassKeysis_elem::Eqa =>a ->[a ]->Boolis_elem =isIn"is_X_Class"