X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelNames.lhs;h=8a823302a1bb95e93834d5db45c1053556740ae6;hb=10fcd78ccde892feccda3f5eacd221c1de75feea;hp=f99fe5f148eb3d8fb785c25fca97e4c89d83888e;hpb=b732f90c9e6b1c0177e04a5f84abac7f50cca4e4;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelNames.lhs b/ghc/compiler/prelude/PrelNames.lhs index f99fe5f..8a82330 100644 --- a/ghc/compiler/prelude/PrelNames.lhs +++ b/ghc/compiler/prelude/PrelNames.lhs @@ -36,19 +36,22 @@ module PrelNames ( #include "HsVersions.h" -import Module ( ModuleName, mkPrelModule, mkModuleName ) -import OccName ( NameSpace, varName, dataName, tcName, clsName ) -import RdrName ( RdrName, mkPreludeQual ) +import Module ( ModuleName, mkPrelModule, mkHomeModule, mkModuleName ) +import OccName ( NameSpace, UserFS, varName, dataName, tcName, clsName, + mkKindOccFS, mkOccFS + ) +import RdrName ( RdrName, mkOrig, mkUnqual ) import UniqFM import Unique ( Unique, Uniquable(..), hasKey, mkPreludeMiscIdUnique, mkPreludeDataConUnique, - mkPreludeTyConUnique, mkPreludeClassUnique + mkPreludeTyConUnique, mkPreludeClassUnique, + mkTupleTyConUnique ) import BasicTypes ( Boxity(..), Arity ) import UniqFM ( UniqFM, listToUFM ) import Name ( Name, mkLocalName, mkKnownKeyGlobal, nameRdrName ) import RdrName ( rdrNameOcc ) -import SrcLoc ( noSrcLoc ) +import SrcLoc ( builtinSrcLoc, noSrcLoc ) import Util ( nOfThem ) import Panic ( panic ) \end{code} @@ -56,6 +59,29 @@ import Panic ( panic ) %************************************************************************ %* * +\subsection{Local Names} +%* * +%************************************************************************ + +This *local* name is used by the interactive stuff + +\begin{code} +itName uniq = mkLocalName uniq (mkOccFS varName SLIT("it")) noSrcLoc +\end{code} + +\begin{code} +-- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly +-- during compiler debugging. +mkUnboundName :: RdrName -> Name +mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) builtinSrcLoc + +isUnboundName :: Name -> Bool +isUnboundName name = name `hasKey` unboundKey +\end{code} + + +%************************************************************************ +%* * \subsection{Known key Names} %* * %************************************************************************ @@ -69,8 +95,8 @@ knownKeyNames :: [Name] knownKeyNames = [ -- Type constructors (synonyms especially) - ioTyConName, - mainName, + ioTyConName, ioDataConName, + runMainName, orderingTyConName, rationalTyConName, ratioDataConName, @@ -78,6 +104,7 @@ knownKeyNames byteArrayTyConName, mutableByteArrayTyConName, foreignObjTyConName, + foreignPtrTyConName, bcoPrimTyConName, stablePtrTyConName, stablePtrDataConName, @@ -106,8 +133,8 @@ knownKeyNames cReturnableClassName, -- mentioned, ccallish -- ClassOps - fromIntName, fromIntegerName, + negateName, geName, minusName, enumFromName, @@ -121,11 +148,16 @@ knownKeyNames returnMName, failMName, fromRationalName, - + + -- not class methods, but overloaded (for parallel arrays) + enumFromToPName, + enumFromThenToPName, + deRefStablePtrName, - makeStablePtrName, + newStablePtrName, bindIOName, returnIOName, + failIOName, -- Strings and lists mapName, @@ -143,6 +175,20 @@ knownKeyNames buildName, augmentName, + -- Parallel array operations + nullPName, + lengthPName, + replicatePName, + mapPName, + filterPName, + zipPName, + crossPName, + indexPName, + toPName, + bpermutePName, + bpermuteDftPName, + indexOfPName, + -- FFI primitive types that are not wired-in. int8TyConName, int16TyConName, @@ -154,12 +200,27 @@ knownKeyNames word64TyConName, -- Others + unsafeCoerceName, otherwiseIdName, plusIntegerName, timesIntegerName, eqStringName, assertName, - runSTRepName + runSTRepName, + printName, + splitName, fstName, sndName, -- Used by splittery + + -- Others (needed for flattening and not mentioned before) + andName, + orName, + eqCharName, + eqIntName, + eqFloatName, + eqDoubleName, + neqCharName, + neqIntName, + neqFloatName, + neqDoubleName ] \end{code} @@ -179,28 +240,38 @@ pREL_SHOW_Name = mkModuleName "PrelShow" pREL_READ_Name = mkModuleName "PrelRead" pREL_NUM_Name = mkModuleName "PrelNum" pREL_LIST_Name = mkModuleName "PrelList" +pREL_PARR_Name = mkModuleName "PrelPArr" pREL_TUP_Name = mkModuleName "PrelTup" pREL_PACK_Name = mkModuleName "PrelPack" pREL_CONC_Name = mkModuleName "PrelConc" pREL_IO_BASE_Name = mkModuleName "PrelIOBase" +pREL_IO_Name = mkModuleName "PrelIO" pREL_ST_Name = mkModuleName "PrelST" pREL_ARR_Name = mkModuleName "PrelArr" pREL_BYTEARR_Name = mkModuleName "PrelByteArr" pREL_FOREIGN_Name = mkModuleName "PrelForeign" pREL_STABLE_Name = mkModuleName "PrelStable" +pREL_SPLIT_Name = mkModuleName "PrelSplit" pREL_ADDR_Name = mkModuleName "PrelAddr" +pREL_PTR_Name = mkModuleName "PrelPtr" pREL_ERR_Name = mkModuleName "PrelErr" pREL_REAL_Name = mkModuleName "PrelReal" pREL_FLOAT_Name = mkModuleName "PrelFloat" +pREL_TOP_HANDLER_Name = mkModuleName "PrelTopHandler" -pREL_MAIN_Name = mkModuleName "PrelMain" mAIN_Name = mkModuleName "Main" -iNT_Name = mkModuleName "Int" -wORD_Name = mkModuleName "Word" +pREL_INT_Name = mkModuleName "PrelInt" +pREL_WORD_Name = mkModuleName "PrelWord" + +fOREIGNOBJ_Name = mkModuleName "ForeignObj" +aDDR_Name = mkModuleName "Addr" + +gLA_EXTS_Name = mkModuleName "GlaExts" pREL_GHC = mkPrelModule pREL_GHC_Name pREL_BASE = mkPrelModule pREL_BASE_Name pREL_ADDR = mkPrelModule pREL_ADDR_Name +pREL_PTR = mkPrelModule pREL_PTR_Name pREL_STABLE = mkPrelModule pREL_STABLE_Name pREL_IO_BASE = mkPrelModule pREL_IO_BASE_Name pREL_PACK = mkPrelModule pREL_PACK_Name @@ -208,6 +279,9 @@ pREL_ERR = mkPrelModule pREL_ERR_Name pREL_NUM = mkPrelModule pREL_NUM_Name pREL_REAL = mkPrelModule pREL_REAL_Name pREL_FLOAT = mkPrelModule pREL_FLOAT_Name +pRELUDE = mkPrelModule pRELUDE_Name + +iNTERACTIVE = mkHomeModule (mkModuleName "$Interactive") \end{code} %************************************************************************ @@ -217,7 +291,7 @@ pREL_FLOAT = mkPrelModule pREL_FLOAT_Name %************************************************************************ \begin{code} -mkTupNameStr :: Boxity -> Int -> (ModuleName, FAST_STRING) +mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS) mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()")) mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???" @@ -235,7 +309,22 @@ mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)" mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of - (mod, occ) -> mkPreludeQual space mod occ + (mod, occ) -> mkOrig space mod occ +\end{code} + + +%************************************************************************ +%* * +\subsection{Unqualified RdrNames} +%* * +%************************************************************************ + +\begin{code} +main_RDR_Unqual :: RdrName +main_RDR_Unqual = mkUnqual varName SLIT("main") +-- Don't get a RdrName from PrelNames.mainName, because nameRdrName +-- gets an Orig RdrName, and we want a Qual or Unqual one. An Unqual +-- one will do fine. \end{code} @@ -245,17 +334,52 @@ mkTupConRdrName space boxity arity = case mkTupNameStr boxity arity of %* * %************************************************************************ -These RdrNames are not really "built in", but some parts of the +Many of these Names are not really "built in", but some parts of the compiler (notably the deriving mechanism) need to mention their names, and it's convenient to write them all down in one place. \begin{code} -mainName = varQual mAIN_Name SLIT("main") mainKey +dollarMainName = varQual mAIN_Name SLIT("$main") dollarMainKey +runMainName = varQual pREL_TOP_HANDLER_Name SLIT("runMain") runMainKey -- Stuff from PrelGHC -funTyConName = tcQual pREL_GHC_Name SLIT("(->)") funTyConKey -cCallableClassName = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey -cReturnableClassName = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey +usOnceTyConName = kindQual SLIT(".") usOnceTyConKey +usManyTyConName = kindQual SLIT("!") usManyTyConKey +superKindName = kindQual SLIT("KX") kindConKey +superBoxityName = kindQual SLIT("BX") boxityConKey +liftedConName = kindQual SLIT("*") liftedConKey +unliftedConName = kindQual SLIT("#") unliftedConKey +openKindConName = kindQual SLIT("?") anyBoxConKey +usageKindConName = kindQual SLIT("$") usageConKey +typeConName = kindQual SLIT("Type") typeConKey + +funTyConName = tcQual pREL_GHC_Name SLIT("(->)") funTyConKey +charPrimTyConName = tcQual pREL_GHC_Name SLIT("Char#") charPrimTyConKey +intPrimTyConName = tcQual pREL_GHC_Name SLIT("Int#") intPrimTyConKey +int32PrimTyConName = tcQual pREL_GHC_Name SLIT("Int32#") int32PrimTyConKey +int64PrimTyConName = tcQual pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey +wordPrimTyConName = tcQual pREL_GHC_Name SLIT("Word#") wordPrimTyConKey +word32PrimTyConName = tcQual pREL_GHC_Name SLIT("Word32#") word32PrimTyConKey +word64PrimTyConName = tcQual pREL_GHC_Name SLIT("Word64#") word64PrimTyConKey +addrPrimTyConName = tcQual pREL_GHC_Name SLIT("Addr#") addrPrimTyConKey +floatPrimTyConName = tcQual pREL_GHC_Name SLIT("Float#") floatPrimTyConKey +doublePrimTyConName = tcQual pREL_GHC_Name SLIT("Double#") doublePrimTyConKey +statePrimTyConName = tcQual pREL_GHC_Name SLIT("State#") statePrimTyConKey +realWorldTyConName = tcQual pREL_GHC_Name SLIT("RealWorld") realWorldTyConKey +arrayPrimTyConName = tcQual pREL_GHC_Name SLIT("Array#") arrayPrimTyConKey +byteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("ByteArray#") byteArrayPrimTyConKey +mutableArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableArray#") mutableArrayPrimTyConKey +mutableByteArrayPrimTyConName = tcQual pREL_GHC_Name SLIT("MutableByteArray#") mutableByteArrayPrimTyConKey +mutVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MutVar#") mutVarPrimTyConKey +mVarPrimTyConName = tcQual pREL_GHC_Name SLIT("MVar#") mVarPrimTyConKey +stablePtrPrimTyConName = tcQual pREL_GHC_Name SLIT("StablePtr#") stablePtrPrimTyConKey +stableNamePrimTyConName = tcQual pREL_GHC_Name SLIT("StableName#") stableNamePrimTyConKey +foreignObjPrimTyConName = tcQual pREL_GHC_Name SLIT("ForeignObj#") foreignObjPrimTyConKey +bcoPrimTyConName = tcQual pREL_GHC_Name SLIT("BCO#") bcoPrimTyConKey +weakPrimTyConName = tcQual pREL_GHC_Name SLIT("Weak#") weakPrimTyConKey +threadIdPrimTyConName = tcQual pREL_GHC_Name SLIT("ThreadId#") threadIdPrimTyConKey +cCallableClassName = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey +cReturnableClassName = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey -- PrelBase data types and constructors charTyConName = tcQual pREL_BASE_Name SLIT("Char") charTyConKey @@ -270,6 +394,10 @@ listTyConName = tcQual pREL_BASE_Name SLIT("[]") listTyConKey nilDataConName = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey consDataConName = dataQual pREL_BASE_Name SLIT(":") consDataConKey +-- PrelTup +fstName = varQual pREL_TUP_Name SLIT("fst") fstIdKey +sndName = varQual pREL_TUP_Name SLIT("snd") sndIdKey + -- Generics crossTyConName = tcQual pREL_BASE_Name SLIT(":*:") crossTyConKey crossDataConName = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey @@ -280,13 +408,25 @@ genUnitTyConName = tcQual pREL_BASE_Name SLIT("Unit") genUnitTyConKey genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey -- Random PrelBase functions +unsafeCoerceName = varQual pREL_BASE_Name SLIT("unsafeCoerce") + unsafeCoerceIdKey otherwiseIdName = varQual pREL_BASE_Name SLIT("otherwise") otherwiseIdKey -appendName = varQual pREL_BASE_Name SLIT("++") appendIdKey -foldrName = varQual pREL_BASE_Name SLIT("foldr") foldrIdKey -mapName = varQual pREL_BASE_Name SLIT("map") mapIdKey -buildName = varQual pREL_BASE_Name SLIT("build") buildIdKey -augmentName = varQual pREL_BASE_Name SLIT("augment") augmentIdKey -eqStringName = varQual pREL_BASE_Name SLIT("eqString") eqStringIdKey +appendName = varQual pREL_BASE_Name SLIT("++") appendIdKey +foldrName = varQual pREL_BASE_Name SLIT("foldr") foldrIdKey +mapName = varQual pREL_BASE_Name SLIT("map") mapIdKey +buildName = varQual pREL_BASE_Name SLIT("build") buildIdKey +augmentName = varQual pREL_BASE_Name SLIT("augment") augmentIdKey +eqStringName = varQual pREL_BASE_Name SLIT("eqString") eqStringIdKey +andName = varQual pREL_BASE_Name SLIT("&&") andIdKey +orName = varQual pREL_BASE_Name SLIT("||") orIdKey +eqCharName = varQual pREL_GHC_Name SLIT("eqChar#") eqCharIdKey +eqIntName = varQual pREL_GHC_Name SLIT("==#") eqIntIdKey +eqFloatName = varQual pREL_GHC_Name SLIT("eqFloat#") eqFloatIdKey +eqDoubleName = varQual pREL_GHC_Name SLIT("==##") eqDoubleIdKey +neqCharName = varQual pREL_GHC_Name SLIT("neqChar#") neqCharIdKey +neqIntName = varQual pREL_GHC_Name SLIT("/=#") neqIntIdKey +neqFloatName = varQual pREL_GHC_Name SLIT("neqFloat#") neqFloatIdKey +neqDoubleName = varQual pREL_GHC_Name SLIT("/=##") neqDoubleIdKey -- Strings unpackCStringName = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey @@ -318,9 +458,9 @@ readClassName = clsQual pREL_READ_Name SLIT("Read") readClassKey -- Module PrelNum numClassName = clsQual pREL_NUM_Name SLIT("Num") numClassKey -fromIntName = varQual pREL_NUM_Name SLIT("fromInt") fromIntClassOpKey fromIntegerName = varQual pREL_NUM_Name SLIT("fromInteger") fromIntegerClassOpKey minusName = varQual pREL_NUM_Name SLIT("-") minusClassOpKey +negateName = varQual pREL_NUM_Name SLIT("negate") negateClassOpKey plusIntegerName = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey timesIntegerName = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey integerTyConName = tcQual pREL_NUM_Name SLIT("Integer") integerTyConKey @@ -357,6 +497,10 @@ enumFromToName = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpK enumFromThenName = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey +-- Overloaded via Class Enum +enumFromToPName = varQual pREL_PARR_Name SLIT("enumFromToP") enumFromToPIdKey +enumFromThenToPName= varQual pREL_PARR_Name SLIT("enumFromThenToP") enumFromThenToPIdKey + -- Class Bounded boundedClassName = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey @@ -365,46 +509,77 @@ concatName = varQual pREL_LIST_Name SLIT("concat") concatIdKey filterName = varQual pREL_LIST_Name SLIT("filter") filterIdKey zipName = varQual pREL_LIST_Name SLIT("zip") zipIdKey +-- parallel array types and functions +parrTyConName = tcQual pREL_PARR_Name SLIT("[::]") parrTyConKey +parrDataConName = dataQual pREL_PARR_Name SLIT("PArr") parrDataConKey +nullPName = varQual pREL_PARR_Name SLIT("nullP") nullPIdKey +lengthPName = varQual pREL_PARR_Name SLIT("lengthP") lengthPIdKey +replicatePName = varQual pREL_PARR_Name SLIT("replicateP") replicatePIdKey +mapPName = varQual pREL_PARR_Name SLIT("mapP") mapPIdKey +filterPName = varQual pREL_PARR_Name SLIT("filterP") filterPIdKey +zipPName = varQual pREL_PARR_Name SLIT("zipP") zipPIdKey +crossPName = varQual pREL_PARR_Name SLIT("crossP") crossPIdKey +indexPName = varQual pREL_PARR_Name SLIT("!:") indexPIdKey +toPName = varQual pREL_PARR_Name SLIT("toP") toPIdKey +bpermutePName = varQual pREL_PARR_Name SLIT("bpermuteP") bpermutePIdKey +bpermuteDftPName = varQual pREL_PARR_Name SLIT("bpermuteDftP") + bpermuteDftPIdKey +indexOfPName = varQual pREL_PARR_Name SLIT("indexOfP") indexOfPIdKey + -- IOBase things ioTyConName = tcQual pREL_IO_BASE_Name SLIT("IO") ioTyConKey ioDataConName = dataQual pREL_IO_BASE_Name SLIT("IO") ioDataConKey bindIOName = varQual pREL_IO_BASE_Name SLIT("bindIO") bindIOIdKey returnIOName = varQual pREL_IO_BASE_Name SLIT("returnIO") returnIOIdKey +failIOName = varQual pREL_IO_BASE_Name SLIT("failIO") failIOIdKey + +-- IO things +printName = varQual pREL_IO_Name SLIT("print") printIdKey -- Int, Word, and Addr things -int8TyConName = tcQual iNT_Name SLIT("Int8") int8TyConKey -int16TyConName = tcQual iNT_Name SLIT("Int16") int16TyConKey -int32TyConName = tcQual iNT_Name SLIT("Int32") int32TyConKey -int64TyConName = tcQual pREL_ADDR_Name SLIT("Int64") int64TyConKey +int8TyConName = tcQual pREL_INT_Name SLIT("Int8") int8TyConKey +int16TyConName = tcQual pREL_INT_Name SLIT("Int16") int16TyConKey +int32TyConName = tcQual pREL_INT_Name SLIT("Int32") int32TyConKey +int64TyConName = tcQual pREL_INT_Name SLIT("Int64") int64TyConKey + +word8TyConName = tcQual pREL_WORD_Name SLIT("Word8") word8TyConKey +word16TyConName = tcQual pREL_WORD_Name SLIT("Word16") word16TyConKey +word32TyConName = tcQual pREL_WORD_Name SLIT("Word32") word32TyConKey +word64TyConName = tcQual pREL_WORD_Name SLIT("Word64") word64TyConKey -wordTyConName = tcQual pREL_ADDR_Name SLIT("Word") wordTyConKey -wordDataConName = dataQual pREL_ADDR_Name SLIT("W#") wordDataConKey -word8TyConName = tcQual wORD_Name SLIT("Word8") word8TyConKey -word16TyConName = tcQual wORD_Name SLIT("Word16") word16TyConKey -word32TyConName = tcQual wORD_Name SLIT("Word32") word32TyConKey -word64TyConName = tcQual pREL_ADDR_Name SLIT("Word64") word64TyConKey +wordTyConName = tcQual pREL_WORD_Name SLIT("Word") wordTyConKey +wordDataConName = dataQual pREL_WORD_Name SLIT("W#") wordDataConKey -addrTyConName = tcQual pREL_ADDR_Name SLIT("Addr") addrTyConKey -addrDataConName = dataQual pREL_ADDR_Name SLIT("A#") addrDataConKey +addrTyConName = tcQual aDDR_Name SLIT("Addr") addrTyConKey +addrDataConName = dataQual aDDR_Name SLIT("A#") addrDataConKey +ptrTyConName = tcQual pREL_PTR_Name SLIT("Ptr") ptrTyConKey +ptrDataConName = dataQual pREL_PTR_Name SLIT("Ptr") ptrDataConKey + +funPtrTyConName = tcQual pREL_PTR_Name SLIT("FunPtr") funPtrTyConKey +funPtrDataConName = dataQual pREL_PTR_Name SLIT("FunPtr") funPtrDataConKey -- Byte array types byteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("ByteArray") byteArrayTyConKey mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name SLIT("MutableByteArray") mutableByteArrayTyConKey --- Forign objects and weak pointers -foreignObjTyConName = tcQual pREL_IO_BASE_Name SLIT("ForeignObj") foreignObjTyConKey -foreignObjDataConName = dataQual pREL_IO_BASE_Name SLIT("ForeignObj") foreignObjDataConKey -bcoPrimTyConName = tcQual pREL_BASE_Name SLIT("BCO#") bcoPrimTyConKey +-- Foreign objects and weak pointers +foreignObjTyConName = tcQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjTyConKey +foreignObjDataConName = dataQual fOREIGNOBJ_Name SLIT("ForeignObj") foreignObjDataConKey +foreignPtrTyConName = tcQual pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrTyConKey +foreignPtrDataConName = dataQual pREL_FOREIGN_Name SLIT("ForeignPtr") foreignPtrDataConKey stablePtrTyConName = tcQual pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey stablePtrDataConName = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey deRefStablePtrName = varQual pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey -makeStablePtrName = varQual pREL_STABLE_Name SLIT("makeStablePtr") makeStablePtrIdKey +newStablePtrName = varQual pREL_STABLE_Name SLIT("newStablePtr") newStablePtrIdKey errorName = varQual pREL_ERR_Name SLIT("error") errorIdKey assertName = varQual pREL_GHC_Name SLIT("assert") assertIdKey getTagName = varQual pREL_GHC_Name SLIT("getTag#") getTagIdKey runSTRepName = varQual pREL_ST_Name SLIT("runSTRep") runSTRepIdKey + +-- The "split" Id for splittable implicit parameters +splitName = varQual pREL_SPLIT_Name SLIT("split") splitIdKey \end{code} %************************************************************************ @@ -417,42 +592,110 @@ The following names are known to the compiler, but they don't require pre-assigned keys. Mostly these names are used in generating deriving code, which is passed through the renamer anyway. + THEY ARE ALL ORIGINAL NAMES, HOWEVER + \begin{code} -and_RDR = varQual_RDR pREL_BASE_Name SLIT("&&") -not_RDR = varQual_RDR pREL_BASE_Name SLIT("not") -compose_RDR = varQual_RDR pREL_BASE_Name SLIT(".") -ne_RDR = varQual_RDR pREL_BASE_Name SLIT("/=") -le_RDR = varQual_RDR pREL_BASE_Name SLIT("<=") -lt_RDR = varQual_RDR pREL_BASE_Name SLIT("<") -gt_RDR = varQual_RDR pREL_BASE_Name SLIT(">") -ltTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("LT") -eqTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("EQ") -gtTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("GT") -max_RDR = varQual_RDR pREL_BASE_Name SLIT("max") -min_RDR = varQual_RDR pREL_BASE_Name SLIT("min") -compare_RDR = varQual_RDR pREL_BASE_Name SLIT("compare") -showList_RDR = varQual_RDR pREL_SHOW_Name SLIT("showList") -showList___RDR = varQual_RDR pREL_SHOW_Name SLIT("showList__") -showsPrec_RDR = varQual_RDR pREL_SHOW_Name SLIT("showsPrec") -showSpace_RDR = varQual_RDR pREL_SHOW_Name SLIT("showSpace") -showString_RDR = varQual_RDR pREL_SHOW_Name SLIT("showString") -showParen_RDR = varQual_RDR pREL_SHOW_Name SLIT("showParen") -readsPrec_RDR = varQual_RDR pREL_READ_Name SLIT("readsPrec") -readList_RDR = varQual_RDR pREL_READ_Name SLIT("readList") -readParen_RDR = varQual_RDR pREL_READ_Name SLIT("readParen") -lex_RDR = varQual_RDR pREL_READ_Name SLIT("lex") -readList___RDR = varQual_RDR pREL_READ_Name SLIT("readList__") -times_RDR = varQual_RDR pREL_NUM_Name SLIT("*") -plus_RDR = varQual_RDR pREL_NUM_Name SLIT("+") -negate_RDR = varQual_RDR pREL_NUM_Name SLIT("negate") -range_RDR = varQual_RDR pREL_ARR_Name SLIT("range") -index_RDR = varQual_RDR pREL_ARR_Name SLIT("index") -inRange_RDR = varQual_RDR pREL_ARR_Name SLIT("inRange") -succ_RDR = varQual_RDR pREL_ENUM_Name SLIT("succ") -pred_RDR = varQual_RDR pREL_ENUM_Name SLIT("pred") -minBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("minBound") -maxBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("maxBound") -assertErr_RDR = varQual_RDR pREL_ERR_Name SLIT("assertError") +-- Lists and tuples +tupleCon_RDR, tupleTyCon_RDR :: Int -> RdrName +ubxTupleCon_RDR, ubxTupleTyCon_RDR :: Int -> RdrName + +tupleCon_RDR = mkTupConRdrName dataName Boxed +tupleTyCon_RDR = mkTupConRdrName tcName Boxed +ubxTupleCon_RDR = mkTupConRdrName dataName Unboxed +ubxTupleTyCon_RDR = mkTupConRdrName tcName Unboxed + +unitCon_RDR = dataQual_RDR pREL_BASE_Name SLIT("()") +unitTyCon_RDR = tcQual_RDR pREL_BASE_Name SLIT("()") + +and_RDR = varQual_RDR pREL_BASE_Name SLIT("&&") +not_RDR = varQual_RDR pREL_BASE_Name SLIT("not") +compose_RDR = varQual_RDR pREL_BASE_Name SLIT(".") +ne_RDR = varQual_RDR pREL_BASE_Name SLIT("/=") +le_RDR = varQual_RDR pREL_BASE_Name SLIT("<=") +lt_RDR = varQual_RDR pREL_BASE_Name SLIT("<") +gt_RDR = varQual_RDR pREL_BASE_Name SLIT(">") +ltTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("LT") +eqTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("EQ") +gtTag_RDR = dataQual_RDR pREL_BASE_Name SLIT("GT") +max_RDR = varQual_RDR pREL_BASE_Name SLIT("max") +min_RDR = varQual_RDR pREL_BASE_Name SLIT("min") +compare_RDR = varQual_RDR pREL_BASE_Name SLIT("compare") +showList_RDR = varQual_RDR pREL_SHOW_Name SLIT("showList") +showList___RDR = varQual_RDR pREL_SHOW_Name SLIT("showList__") +showsPrec_RDR = varQual_RDR pREL_SHOW_Name SLIT("showsPrec") +showSpace_RDR = varQual_RDR pREL_SHOW_Name SLIT("showSpace") +showString_RDR = varQual_RDR pREL_SHOW_Name SLIT("showString") +showParen_RDR = varQual_RDR pREL_SHOW_Name SLIT("showParen") +readsPrec_RDR = varQual_RDR pREL_READ_Name SLIT("readsPrec") +readList_RDR = varQual_RDR pREL_READ_Name SLIT("readList") +readParen_RDR = varQual_RDR pREL_READ_Name SLIT("readParen") +lex_RDR = varQual_RDR pREL_READ_Name SLIT("lex") +readList___RDR = varQual_RDR pREL_READ_Name SLIT("readList__") +times_RDR = varQual_RDR pREL_NUM_Name SLIT("*") +plus_RDR = varQual_RDR pREL_NUM_Name SLIT("+") +negate_RDR = varQual_RDR pREL_NUM_Name SLIT("negate") +range_RDR = varQual_RDR pREL_ARR_Name SLIT("range") +index_RDR = varQual_RDR pREL_ARR_Name SLIT("index") +inRange_RDR = varQual_RDR pREL_ARR_Name SLIT("inRange") +succ_RDR = varQual_RDR pREL_ENUM_Name SLIT("succ") +pred_RDR = varQual_RDR pREL_ENUM_Name SLIT("pred") +minBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("minBound") +maxBound_RDR = varQual_RDR pREL_ENUM_Name SLIT("maxBound") +assertErr_RDR = varQual_RDR pREL_ERR_Name SLIT("assertError") +\end{code} + +These RDR names also have known keys, so we need to get back the RDR names to +populate the occurrence list above. + +\begin{code} +funTyCon_RDR = nameRdrName funTyConName +nilCon_RDR = nameRdrName nilDataConName +listTyCon_RDR = nameRdrName listTyConName +parrTyCon_RDR = nameRdrName parrTyConName +ioTyCon_RDR = nameRdrName ioTyConName +intTyCon_RDR = nameRdrName intTyConName +eq_RDR = nameRdrName eqName +ge_RDR = nameRdrName geName +numClass_RDR = nameRdrName numClassName +ordClass_RDR = nameRdrName ordClassName +map_RDR = nameRdrName mapName +append_RDR = nameRdrName appendName +foldr_RDR = nameRdrName foldrName +build_RDR = nameRdrName buildName +enumFromTo_RDR = nameRdrName enumFromToName +returnM_RDR = nameRdrName returnMName +thenM_RDR = nameRdrName thenMName +failM_RDR = nameRdrName failMName +false_RDR = nameRdrName falseDataConName +true_RDR = nameRdrName trueDataConName +error_RDR = nameRdrName errorName +getTag_RDR = nameRdrName getTagName +fromEnum_RDR = nameRdrName fromEnumName +toEnum_RDR = nameRdrName toEnumName +enumFrom_RDR = nameRdrName enumFromName +mkInt_RDR = nameRdrName intDataConName +enumFromThen_RDR = nameRdrName enumFromThenName +enumFromThenTo_RDR = nameRdrName enumFromThenToName +ratioDataCon_RDR = nameRdrName ratioDataConName +plusInteger_RDR = nameRdrName plusIntegerName +timesInteger_RDR = nameRdrName timesIntegerName +enumClass_RDR = nameRdrName enumClassName +monadClass_RDR = nameRdrName monadClassName +ioDataCon_RDR = nameRdrName ioDataConName +cCallableClass_RDR = nameRdrName cCallableClassName +cReturnableClass_RDR = nameRdrName cReturnableClassName +eqClass_RDR = nameRdrName eqClassName +eqString_RDR = nameRdrName eqStringName +unpackCString_RDR = nameRdrName unpackCStringName +unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName +unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name +deRefStablePtr_RDR = nameRdrName deRefStablePtrName +newStablePtr_RDR = nameRdrName newStablePtrName +bindIO_RDR = nameRdrName bindIOName +returnIO_RDR = nameRdrName returnIOName +fromInteger_RDR = nameRdrName fromIntegerName +fromRational_RDR = nameRdrName fromRationalName +minus_RDR = nameRdrName minusName \end{code} %************************************************************************ @@ -461,14 +704,23 @@ assertErr_RDR = varQual_RDR pREL_ERR_Name SLIT("assertError") %* * %************************************************************************ -\begin{code} -varQual mod str uq = mkKnownKeyGlobal (mkPreludeQual varName mod str) uq -dataQual mod str uq = mkKnownKeyGlobal (mkPreludeQual dataName mod str) uq -tcQual mod str uq = mkKnownKeyGlobal (mkPreludeQual tcName mod str) uq -clsQual mod str uq = mkKnownKeyGlobal (mkPreludeQual clsName mod str) uq +All these are original names; hence mkOrig -varQual_RDR mod str = mkPreludeQual varName mod str -dataQual_RDR mod str = mkPreludeQual dataName mod str +\begin{code} +varQual mod str uq = mkKnownKeyGlobal (varQual_RDR mod str) uq +dataQual mod str uq = mkKnownKeyGlobal (dataQual_RDR mod str) uq +tcQual mod str uq = mkKnownKeyGlobal (tcQual_RDR mod str) uq +clsQual mod str uq = mkKnownKeyGlobal (clsQual_RDR mod str) uq + +kindQual str uq = mkLocalName uq (mkKindOccFS tcName str) builtinSrcLoc + -- Kinds are not z-encoded in interface file, hence mkKindOccFS + -- And they don't come from any particular module; indeed we always + -- want to print them unqualified. Hence the LocalName + +varQual_RDR mod str = mkOrig varName mod str +tcQual_RDR mod str = mkOrig tcName mod str +clsQual_RDR mod str = mkOrig clsName mod str +dataQual_RDR mod str = mkOrig dataName mod str \end{code} %************************************************************************ @@ -524,50 +776,65 @@ intPrimTyConKey = mkPreludeTyConUnique 14 intTyConKey = mkPreludeTyConUnique 15 int8TyConKey = mkPreludeTyConUnique 16 int16TyConKey = mkPreludeTyConUnique 17 -int32TyConKey = mkPreludeTyConUnique 18 -int64PrimTyConKey = mkPreludeTyConUnique 19 -int64TyConKey = mkPreludeTyConUnique 20 -integerTyConKey = mkPreludeTyConUnique 21 -listTyConKey = mkPreludeTyConUnique 22 -foreignObjPrimTyConKey = mkPreludeTyConUnique 23 -foreignObjTyConKey = mkPreludeTyConUnique 24 -weakPrimTyConKey = mkPreludeTyConUnique 25 -mutableArrayPrimTyConKey = mkPreludeTyConUnique 26 -mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 27 -orderingTyConKey = mkPreludeTyConUnique 28 -mVarPrimTyConKey = mkPreludeTyConUnique 29 -ratioTyConKey = mkPreludeTyConUnique 30 -rationalTyConKey = mkPreludeTyConUnique 31 -realWorldTyConKey = mkPreludeTyConUnique 32 -stablePtrPrimTyConKey = mkPreludeTyConUnique 33 -stablePtrTyConKey = mkPreludeTyConUnique 34 -statePrimTyConKey = mkPreludeTyConUnique 35 -stableNamePrimTyConKey = mkPreludeTyConUnique 50 -stableNameTyConKey = mkPreludeTyConUnique 51 -mutableByteArrayTyConKey = mkPreludeTyConUnique 52 -mutVarPrimTyConKey = mkPreludeTyConUnique 53 -ioTyConKey = mkPreludeTyConUnique 55 -byteArrayTyConKey = mkPreludeTyConUnique 56 -wordPrimTyConKey = mkPreludeTyConUnique 57 -wordTyConKey = mkPreludeTyConUnique 58 -word8TyConKey = mkPreludeTyConUnique 59 -word16TyConKey = mkPreludeTyConUnique 60 -word32TyConKey = mkPreludeTyConUnique 61 -word64PrimTyConKey = mkPreludeTyConUnique 62 -word64TyConKey = mkPreludeTyConUnique 63 -boxedConKey = mkPreludeTyConUnique 64 -unboxedConKey = mkPreludeTyConUnique 65 -anyBoxConKey = mkPreludeTyConUnique 66 -kindConKey = mkPreludeTyConUnique 67 -boxityConKey = mkPreludeTyConUnique 68 -typeConKey = mkPreludeTyConUnique 69 -threadIdPrimTyConKey = mkPreludeTyConUnique 70 -bcoPrimTyConKey = mkPreludeTyConUnique 71 +int32PrimTyConKey = mkPreludeTyConUnique 18 +int32TyConKey = mkPreludeTyConUnique 19 +int64PrimTyConKey = mkPreludeTyConUnique 20 +int64TyConKey = mkPreludeTyConUnique 21 +integerTyConKey = mkPreludeTyConUnique 22 +listTyConKey = mkPreludeTyConUnique 23 +foreignObjPrimTyConKey = mkPreludeTyConUnique 24 +foreignObjTyConKey = mkPreludeTyConUnique 25 +foreignPtrTyConKey = mkPreludeTyConUnique 26 +weakPrimTyConKey = mkPreludeTyConUnique 27 +mutableArrayPrimTyConKey = mkPreludeTyConUnique 28 +mutableByteArrayPrimTyConKey = mkPreludeTyConUnique 29 +orderingTyConKey = mkPreludeTyConUnique 30 +mVarPrimTyConKey = mkPreludeTyConUnique 31 +ratioTyConKey = mkPreludeTyConUnique 32 +rationalTyConKey = mkPreludeTyConUnique 33 +realWorldTyConKey = mkPreludeTyConUnique 34 +stablePtrPrimTyConKey = mkPreludeTyConUnique 35 +stablePtrTyConKey = mkPreludeTyConUnique 36 +statePrimTyConKey = mkPreludeTyConUnique 50 +stableNamePrimTyConKey = mkPreludeTyConUnique 51 +stableNameTyConKey = mkPreludeTyConUnique 52 +mutableByteArrayTyConKey = mkPreludeTyConUnique 53 +mutVarPrimTyConKey = mkPreludeTyConUnique 55 +ioTyConKey = mkPreludeTyConUnique 56 +byteArrayTyConKey = mkPreludeTyConUnique 57 +wordPrimTyConKey = mkPreludeTyConUnique 58 +wordTyConKey = mkPreludeTyConUnique 59 +word8TyConKey = mkPreludeTyConUnique 60 +word16TyConKey = mkPreludeTyConUnique 61 +word32PrimTyConKey = mkPreludeTyConUnique 62 +word32TyConKey = mkPreludeTyConUnique 63 +word64PrimTyConKey = mkPreludeTyConUnique 64 +word64TyConKey = mkPreludeTyConUnique 65 +liftedConKey = mkPreludeTyConUnique 66 +unliftedConKey = mkPreludeTyConUnique 67 +anyBoxConKey = mkPreludeTyConUnique 68 +kindConKey = mkPreludeTyConUnique 69 +boxityConKey = mkPreludeTyConUnique 70 +typeConKey = mkPreludeTyConUnique 71 +threadIdPrimTyConKey = mkPreludeTyConUnique 72 +bcoPrimTyConKey = mkPreludeTyConUnique 73 +ptrTyConKey = mkPreludeTyConUnique 74 +funPtrTyConKey = mkPreludeTyConUnique 75 + +-- Usage type constructors +usageConKey = mkPreludeTyConUnique 76 +usOnceTyConKey = mkPreludeTyConUnique 77 +usManyTyConKey = mkPreludeTyConUnique 78 -- Generic Type Constructors -crossTyConKey = mkPreludeTyConUnique 72 -plusTyConKey = mkPreludeTyConUnique 73 -genUnitTyConKey = mkPreludeTyConUnique 74 +crossTyConKey = mkPreludeTyConUnique 79 +plusTyConKey = mkPreludeTyConUnique 80 +genUnitTyConKey = mkPreludeTyConUnique 81 + +-- Parallel array type constructor +parrTyConKey = mkPreludeTyConUnique 82 + +unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} %************************************************************************ @@ -587,19 +854,25 @@ intDataConKey = mkPreludeDataConUnique 6 smallIntegerDataConKey = mkPreludeDataConUnique 7 largeIntegerDataConKey = mkPreludeDataConUnique 8 foreignObjDataConKey = mkPreludeDataConUnique 9 -nilDataConKey = mkPreludeDataConUnique 10 -ratioDataConKey = mkPreludeDataConUnique 11 -stablePtrDataConKey = mkPreludeDataConUnique 12 -stableNameDataConKey = mkPreludeDataConUnique 13 -trueDataConKey = mkPreludeDataConUnique 14 -wordDataConKey = mkPreludeDataConUnique 15 -ioDataConKey = mkPreludeDataConUnique 16 +foreignPtrDataConKey = mkPreludeDataConUnique 10 +nilDataConKey = mkPreludeDataConUnique 11 +ratioDataConKey = mkPreludeDataConUnique 12 +stablePtrDataConKey = mkPreludeDataConUnique 13 +stableNameDataConKey = mkPreludeDataConUnique 14 +trueDataConKey = mkPreludeDataConUnique 15 +wordDataConKey = mkPreludeDataConUnique 16 +ioDataConKey = mkPreludeDataConUnique 17 +ptrDataConKey = mkPreludeDataConUnique 18 +funPtrDataConKey = mkPreludeDataConUnique 19 -- Generic data constructors -crossDataConKey = mkPreludeDataConUnique 17 -inlDataConKey = mkPreludeDataConUnique 18 -inrDataConKey = mkPreludeDataConUnique 19 -genUnitDataConKey = mkPreludeDataConUnique 20 +crossDataConKey = mkPreludeDataConUnique 20 +inlDataConKey = mkPreludeDataConUnique 21 +inrDataConKey = mkPreludeDataConUnique 22 +genUnitDataConKey = mkPreludeDataConUnique 23 + +-- Data constructor for parallel arrays +parrDataConKey = mkPreludeDataConUnique 24 \end{code} %************************************************************************ @@ -622,10 +895,12 @@ integerPlusOneIdKey = mkPreludeMiscIdUnique 10 integerPlusTwoIdKey = mkPreludeMiscIdUnique 11 integerZeroIdKey = mkPreludeMiscIdUnique 12 int2IntegerIdKey = mkPreludeMiscIdUnique 13 +seqIdKey = mkPreludeMiscIdUnique 14 irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 eqStringIdKey = mkPreludeMiscIdUnique 16 noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 +errorCStringIdKey = mkPreludeMiscIdUnique 19 parErrorIdKey = mkPreludeMiscIdUnique 20 parIdKey = mkPreludeMiscIdUnique 21 patErrorIdKey = mkPreludeMiscIdUnique 22 @@ -645,10 +920,53 @@ zipIdKey = mkPreludeMiscIdUnique 35 bindIOIdKey = mkPreludeMiscIdUnique 36 returnIOIdKey = mkPreludeMiscIdUnique 37 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 -makeStablePtrIdKey = mkPreludeMiscIdUnique 39 +newStablePtrIdKey = mkPreludeMiscIdUnique 39 getTagIdKey = mkPreludeMiscIdUnique 40 plusIntegerIdKey = mkPreludeMiscIdUnique 41 timesIntegerIdKey = mkPreludeMiscIdUnique 42 +printIdKey = mkPreludeMiscIdUnique 43 +failIOIdKey = mkPreludeMiscIdUnique 44 +nullAddrIdKey = mkPreludeMiscIdUnique 46 +voidArgIdKey = mkPreludeMiscIdUnique 47 +splitIdKey = mkPreludeMiscIdUnique 48 +fstIdKey = mkPreludeMiscIdUnique 49 +sndIdKey = mkPreludeMiscIdUnique 50 +otherwiseIdKey = mkPreludeMiscIdUnique 51 +mapIdKey = mkPreludeMiscIdUnique 52 +assertIdKey = mkPreludeMiscIdUnique 53 +runSTRepIdKey = mkPreludeMiscIdUnique 54 + +dollarMainKey = mkPreludeMiscIdUnique 55 +runMainKey = mkPreludeMiscIdUnique 56 + +andIdKey = mkPreludeMiscIdUnique 57 +orIdKey = mkPreludeMiscIdUnique 58 +eqCharIdKey = mkPreludeMiscIdUnique 59 +eqIntIdKey = mkPreludeMiscIdUnique 60 +eqFloatIdKey = mkPreludeMiscIdUnique 61 +eqDoubleIdKey = mkPreludeMiscIdUnique 62 +neqCharIdKey = mkPreludeMiscIdUnique 63 +neqIntIdKey = mkPreludeMiscIdUnique 64 +neqFloatIdKey = mkPreludeMiscIdUnique 65 +neqDoubleIdKey = mkPreludeMiscIdUnique 66 + +-- NB: Currently a gap of four slots + +-- Parallel array functions +nullPIdKey = mkPreludeMiscIdUnique 70 +lengthPIdKey = mkPreludeMiscIdUnique 71 +replicatePIdKey = mkPreludeMiscIdUnique 72 +mapPIdKey = mkPreludeMiscIdUnique 73 +filterPIdKey = mkPreludeMiscIdUnique 74 +zipPIdKey = mkPreludeMiscIdUnique 75 +crossPIdKey = mkPreludeMiscIdUnique 76 +indexPIdKey = mkPreludeMiscIdUnique 77 +toPIdKey = mkPreludeMiscIdUnique 78 +enumFromToPIdKey = mkPreludeMiscIdUnique 79 +enumFromThenToPIdKey = mkPreludeMiscIdUnique 80 +bpermutePIdKey = mkPreludeMiscIdUnique 81 +bpermuteDftPIdKey = mkPreludeMiscIdUnique 82 +indexOfPIdKey = mkPreludeMiscIdUnique 83 \end{code} Certain class operations from Prelude classes. They get their own @@ -656,7 +974,8 @@ uniques so we can look them up easily when we want to conjure them up during type checking. \begin{code} -fromIntClassOpKey = mkPreludeMiscIdUnique 101 + -- Just a place holder for unbound variables produced by the renamer: +unboundKey = mkPreludeMiscIdUnique 101 fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 minusClassOpKey = mkPreludeMiscIdUnique 103 fromRationalClassOpKey = mkPreludeMiscIdUnique 104 @@ -666,22 +985,12 @@ enumFromToClassOpKey = mkPreludeMiscIdUnique 107 enumFromThenToClassOpKey = mkPreludeMiscIdUnique 108 eqClassOpKey = mkPreludeMiscIdUnique 109 geClassOpKey = mkPreludeMiscIdUnique 110 +negateClassOpKey = mkPreludeMiscIdUnique 111 failMClassOpKey = mkPreludeMiscIdUnique 112 thenMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) - -- Just a place holder for unbound variables produced by the renamer: -unboundKey = mkPreludeMiscIdUnique 114 fromEnumClassOpKey = mkPreludeMiscIdUnique 115 - -mainKey = mkPreludeMiscIdUnique 116 returnMClassOpKey = mkPreludeMiscIdUnique 117 -otherwiseIdKey = mkPreludeMiscIdUnique 118 toEnumClassOpKey = mkPreludeMiscIdUnique 119 -mapIdKey = mkPreludeMiscIdUnique 120 -\end{code} - -\begin{code} -assertIdKey = mkPreludeMiscIdUnique 121 -runSTRepIdKey = mkPreludeMiscIdUnique 122 \end{code} @@ -709,6 +1018,7 @@ cCallishTyKeys = , byteArrayTyConKey , mutableByteArrayTyConKey , foreignObjTyConKey + , foreignPtrTyConKey , stablePtrTyConKey , int8TyConKey , int16TyConKey @@ -781,32 +1091,6 @@ deriving_occ_info -- or for taggery. -- ordClass: really it's the methods that are actually used. -- numClass: for Int literals - --- these RDR names also have known keys, so we need to get back the RDR names to --- populate the occurrence list above. -intTyCon_RDR = nameRdrName intTyConName -eq_RDR = nameRdrName eqName -ge_RDR = nameRdrName geName -numClass_RDR = nameRdrName numClassName -ordClass_RDR = nameRdrName ordClassName -map_RDR = nameRdrName mapName -append_RDR = nameRdrName appendName -foldr_RDR = nameRdrName foldrName -build_RDR = nameRdrName buildName -enumFromTo_RDR = nameRdrName enumFromToName -returnM_RDR = nameRdrName returnMName -thenM_RDR = nameRdrName thenMName -failM_RDR = nameRdrName failMName -false_RDR = nameRdrName falseDataConName -true_RDR = nameRdrName trueDataConName -error_RDR = nameRdrName errorName -getTag_RDR = nameRdrName getTagName -fromEnum_RDR = nameRdrName fromEnumName -toEnum_RDR = nameRdrName toEnumName -enumFrom_RDR = nameRdrName enumFromName -mkInt_RDR = nameRdrName intDataConName -enumFromThen_RDR = nameRdrName enumFromThenName -enumFromThenTo_RDR = nameRdrName enumFromThenToName \end{code} @@ -855,12 +1139,3 @@ noDictClassKeys -- These classes are used only for type annotations; = cCallishClassKeys \end{code} -\begin{code} --- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly --- during compiler debugging. -mkUnboundName :: RdrName -> Name -mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) noSrcLoc - -isUnboundName :: Name -> Bool -isUnboundName name = name `hasKey` unboundKey -\end{code}