X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelNames.lhs;h=69d924f5eb5ef9e6b2bcd912156555eae51513a1;hb=0d197643ea29ae54ed91e51fc890893b2ae5e16c;hp=391a77d20cc47803f41d8f427b532700fcd5ae99;hpb=bca9dd54c2b39638cb4638aaccf6015a104a1df5;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelNames.lhs b/ghc/compiler/prelude/PrelNames.lhs index 391a77d..69d924f 100644 --- a/ghc/compiler/prelude/PrelNames.lhs +++ b/ghc/compiler/prelude/PrelNames.lhs @@ -1,56 +1,91 @@ % % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % -\section[PrelNames]{Definitions of prelude modules} +\section[PrelNames]{Definitions of prelude modules and names} -The strings identify built-in prelude modules. They are -defined here so as to avod -[oh dear, looks like the recursive module monster caught up with - and gobbled whoever was writing the above :-) -- SOF ] +Nota Bene: all Names defined in here should come from the base package + +* ModuleNames for prelude modules, + e.g. pREL_BASE_Name :: ModuleName + +* Modules for prelude modules + e.g. pREL_Base :: Module + +* Uniques for Ids, DataCons, TyCons and Classes that the compiler + "knows about" in some way + e.g. intTyConKey :: Unique + minusClassOpKey :: Unique + +* Names for Ids, DataCons, TyCons and Classes that the compiler + "knows about" in some way + e.g. intTyConName :: Name + minusName :: Name + One of these Names contains + (a) the module and occurrence name of the thing + (b) its Unique + The may way the compiler "knows about" one of these things is + where the type checker or desugarer needs to look it up. For + example, when desugaring list comprehensions the desugarer + needs to conjure up 'foldr'. It does this by looking up + foldrName in the environment. + +* RdrNames for Ids, DataCons etc that the compiler may emit into + generated code (e.g. for deriving). It's not necessary to know + the uniques for these guys, only their names + \begin{code} module PrelNames ( Unique, Uniquable(..), hasKey, -- Re-exported for convenience ----------------------------------------------------------- - module PrelNames, -- A huge bunch of (a) RdrNames, e.g. intTyCon_RDR - -- (b) Uniques e.g. intTyConKey + module PrelNames, -- A huge bunch of (a) Names, e.g. intTyConName + -- (b) Uniques e.g. intTyConKey + -- (c) Groups of classes and types + -- (d) miscellaneous things -- So many that we export them all - - ----------------------------------------------------------- - knownKeyNames, - mkTupNameStr, mkTupConRdrName, - - ------------------------------------------------------------ - -- Goups of classes and types - needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys, - fractionalClassKeys, numericClassKeys, standardClassKeys, - derivingOccurrences, -- For a given class C, this tells what other - derivableClassKeys, -- things are needed as a result of a - -- deriving(C) clause - numericTyKeys, cCallishTyKeys, - - mkUnboundName, isUnboundName ) where #include "HsVersions.h" -import Module ( ModuleName, mkPrelModule, mkModuleName ) -import OccName ( NameSpace, UserFS, varName, dataName, tcName, clsName, mkKindOccFS ) -import RdrName ( RdrName, mkOrig, mkRdrOrig ) -import UniqFM +import Module ( Module, mkModule ) +import OccName ( dataName, tcName, clsName, varName, mkOccFS + ) + +import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual ) 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 Name ( Name, mkInternalName, mkExternalName, nameModule ) import SrcLoc ( noSrcLoc ) -import Util ( nOfThem ) -import Panic ( panic ) +import FastString +\end{code} + + +%************************************************************************ +%* * +\subsection{Local Names} +%* * +%************************************************************************ + +This *local* name is used by the interactive stuff + +\begin{code} +itName uniq = mkInternalName uniq (mkOccFS varName FSLIT("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 = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcLoc + +isUnboundName :: Name -> Bool +isUnboundName name = name `hasKey` unboundKey \end{code} @@ -65,22 +100,21 @@ names with uniques. These ones are the *non* wired-in ones. The wired in ones are defined in TysWiredIn etc. \begin{code} -knownKeyNames :: [Name] -knownKeyNames - = [ - -- Type constructors (synonyms especially) - ioTyConName, - mainName, +basicKnownKeyNames :: [Name] +basicKnownKeyNames + = genericTyConNames + ++ monadNames + ++ typeableClassNames + ++ [ -- Type constructors (synonyms especially) + ioTyConName, ioDataConName, + runMainIOName, orderingTyConName, rationalTyConName, ratioDataConName, ratioTyConName, byteArrayTyConName, mutableByteArrayTyConName, - foreignObjTyConName, - bcoPrimTyConName, - stablePtrTyConName, - stablePtrDataConName, + integerTyConName, smallIntegerDataConName, largeIntegerDataConName, -- Classes. *Must* include: -- classes that are grabbed by key (e.g., eqClassKey) @@ -91,76 +125,93 @@ knownKeyNames numClassName, -- mentioned, numeric enumClassName, -- derivable monadClassName, - monadPlusClassName, functorClassName, - showClassName, -- derivable realClassName, -- numeric integralClassName, -- numeric fractionalClassName, -- numeric floatingClassName, -- numeric realFracClassName, -- numeric realFloatClassName, -- numeric - readClassName, -- derivable - ixClassName, -- derivable (but it isn't Prelude.Ix; hmmm) - cCallableClassName, -- mentioned, ccallish - cReturnableClassName, -- mentioned, ccallish - - -- ClassOps - fromIntName, - fromIntegerName, - geName, - minusName, - enumFromName, - enumFromThenName, - enumFromToName, - enumFromThenToName, - fromEnumName, - toEnumName, - eqName, - thenMName, - returnMName, - failMName, - fromRationalName, - - deRefStablePtrName, + dataClassName, + + -- Numeric stuff + negateName, minusName, + fromRationalName, fromIntegerName, + geName, eqName, + + -- Enum stuff + enumFromName, enumFromThenName, + enumFromThenToName, enumFromToName, + enumFromToPName, enumFromThenToPName, + + -- Monad stuff + thenIOName, bindIOName, returnIOName, failIOName, + + -- MonadRec stuff + mfixName, + + -- Arrow stuff + arrAName, composeAName, firstAName, + appAName, choiceAName, loopAName, + + -- Ix stuff + ixClassName, + + -- Show stuff + showClassName, + + -- Read stuff + readClassName, + + -- Stable pointers newStablePtrName, - bindIOName, - returnIOName, -- Strings and lists - mapName, - appendName, - unpackCStringName, - unpackCStringAppendName, - unpackCStringFoldrName, - unpackCStringUtf8Name, + unpackCStringName, unpackCStringAppendName, + unpackCStringFoldrName, unpackCStringUtf8Name, -- List operations - concatName, - filterName, - zipName, - foldrName, - buildName, - augmentName, + concatName, filterName, + zipName, foldrName, buildName, augmentName, appendName, + + -- 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, - int32TyConName, - int64TyConName, - word8TyConName, - word16TyConName, - word32TyConName, - word64TyConName, + stablePtrTyConName, ptrTyConName, funPtrTyConName, addrTyConName, + int8TyConName, int16TyConName, int32TyConName, int64TyConName, + wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName, -- Others - otherwiseIdName, - plusIntegerName, - timesIntegerName, - eqStringName, - assertName, - runSTRepName + otherwiseIdName, + plusIntegerName, timesIntegerName, + eqStringName, assertName, assertErrorName, runSTRepName, + printName, fstName, sndName, + + -- MonadFix + monadFixClassName, mfixName, + + -- Splittable class + splittableClassName, splitName, + + -- Booleans + andName, orName + + -- The Either type + , eitherTyConName, leftDataConName, rightDataConName + + -- dotnet interop + , objectTyConName, marshalObjectName, unmarshalObjectName + , marshalStringName, unmarshalStringName, checkDotnetResName ] + +monadNames :: [Name] -- The monad ops need by a HsDo +monadNames = [returnMName, failMName, bindMName, thenMName] + +genericTyConNames :: [Name] +genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] \end{code} @@ -170,44 +221,57 @@ knownKeyNames %* * %************************************************************************ + +--MetaHaskell Extension Add a new module here \begin{code} -pRELUDE_Name = mkModuleName "Prelude" -pREL_GHC_Name = mkModuleName "PrelGHC" -- Primitive types and values -pREL_BASE_Name = mkModuleName "PrelBase" -pREL_ENUM_Name = mkModuleName "PrelEnum" -pREL_SHOW_Name = mkModuleName "PrelShow" -pREL_READ_Name = mkModuleName "PrelRead" -pREL_NUM_Name = mkModuleName "PrelNum" -pREL_LIST_Name = mkModuleName "PrelList" -pREL_TUP_Name = mkModuleName "PrelTup" -pREL_PACK_Name = mkModuleName "PrelPack" -pREL_CONC_Name = mkModuleName "PrelConc" -pREL_IO_BASE_Name = mkModuleName "PrelIOBase" -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_ADDR_Name = mkModuleName "PrelAddr" -pREL_ERR_Name = mkModuleName "PrelErr" -pREL_REAL_Name = mkModuleName "PrelReal" -pREL_FLOAT_Name = mkModuleName "PrelFloat" - -pREL_MAIN_Name = mkModuleName "PrelMain" -mAIN_Name = mkModuleName "Main" -iNT_Name = mkModuleName "Int" -wORD_Name = mkModuleName "Word" - -pREL_GHC = mkPrelModule pREL_GHC_Name -pREL_BASE = mkPrelModule pREL_BASE_Name -pREL_ADDR = mkPrelModule pREL_ADDR_Name -pREL_STABLE = mkPrelModule pREL_STABLE_Name -pREL_IO_BASE = mkPrelModule pREL_IO_BASE_Name -pREL_PACK = mkPrelModule pREL_PACK_Name -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 = mkModule "Prelude" +gHC_PRIM = mkModule "GHC.Prim" -- Primitive types and values +pREL_BASE = mkModule "GHC.Base" +pREL_ENUM = mkModule "GHC.Enum" +pREL_SHOW = mkModule "GHC.Show" +pREL_READ = mkModule "GHC.Read" +pREL_NUM = mkModule "GHC.Num" +pREL_LIST = mkModule "GHC.List" +pREL_PARR = mkModule "GHC.PArr" +pREL_TUP = mkModule "Data.Tuple" +pREL_EITHER = mkModule "Data.Either" +pREL_PACK = mkModule "GHC.Pack" +pREL_CONC = mkModule "GHC.Conc" +pREL_IO_BASE = mkModule "GHC.IOBase" +pREL_ST = mkModule "GHC.ST" +pREL_ARR = mkModule "GHC.Arr" +pREL_BYTEARR = mkModule "PrelByteArr" +pREL_STABLE = mkModule "GHC.Stable" +pREL_ADDR = mkModule "GHC.Addr" +pREL_PTR = mkModule "GHC.Ptr" +pREL_ERR = mkModule "GHC.Err" +pREL_REAL = mkModule "GHC.Real" +pREL_FLOAT = mkModule "GHC.Float" +pREL_TOP_HANDLER= mkModule "GHC.TopHandler" +sYSTEM_IO = mkModule "System.IO" +dYNAMIC = mkModule "Data.Dynamic" +tYPEABLE = mkModule "Data.Typeable" +gENERICS = mkModule "Data.Generics.Basics" +dOTNET = mkModule "GHC.Dotnet" + +rEAD_PREC = mkModule "Text.ParserCombinators.ReadPrec" +lEX = mkModule "Text.Read.Lex" + +mAIN = mkModule "Main" +pREL_INT = mkModule "GHC.Int" +pREL_WORD = mkModule "GHC.Word" +mONAD_FIX = mkModule "Control.Monad.Fix" +aRROW = mkModule "Control.Arrow" +aDDR = mkModule "Addr" + +gLA_EXTS = mkModule "GHC.Exts" +rOOT_MAIN = mkModule ":Main" -- Root module for initialisation + -- The ':xxx' makes a moudle name that the user can never + -- use himself. The z-encoding for ':' is "ZC", so the z-encoded + -- module name still starts with a capital letter, which keeps + -- the z-encoded version consistent. + +iNTERACTIVE = mkModule ":Interactive" \end{code} %************************************************************************ @@ -217,341 +281,356 @@ pREL_FLOAT = mkPrelModule pREL_FLOAT_Name %************************************************************************ \begin{code} -mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS) - -mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()")) -mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???" -mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)") -- not strictly necessary -mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)") -- ditto -mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto -mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")")) - -mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???" -mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!! -mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)") -mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)") -mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)") -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) -> mkOrig space mod occ +mkTupleModule :: Boxity -> Arity -> Module +mkTupleModule Boxed 0 = pREL_BASE +mkTupleModule Boxed _ = pREL_TUP +mkTupleModule Unboxed _ = gHC_PRIM \end{code} %************************************************************************ %* * -\subsection{Commonly-used RdrNames} + RdrNames %* * %************************************************************************ -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 - --- Stuff from PrelGHC -usOnceTyConName = kindQual SLIT(".") usOnceTyConKey -usManyTyConName = kindQual SLIT("!") usManyTyConKey -superKindName = kindQual SLIT("KX") kindConKey -superBoxityName = kindQual SLIT("BX") boxityConKey -boxedConName = kindQual SLIT("*") boxedConKey -unboxedConName = kindQual SLIT("#") unboxedConKey -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 -int64PrimTyConName = tcQual pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey -wordPrimTyConName = tcQual pREL_GHC_Name SLIT("Word#") wordPrimTyConKey -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 -charDataConName = dataQual pREL_BASE_Name SLIT("C#") charDataConKey -intTyConName = tcQual pREL_BASE_Name SLIT("Int") intTyConKey -intDataConName = dataQual pREL_BASE_Name SLIT("I#") intDataConKey -orderingTyConName = tcQual pREL_BASE_Name SLIT("Ordering") orderingTyConKey -boolTyConName = tcQual pREL_BASE_Name SLIT("Bool") boolTyConKey -falseDataConName = dataQual pREL_BASE_Name SLIT("False") falseDataConKey -trueDataConName = dataQual pREL_BASE_Name SLIT("True") trueDataConKey -listTyConName = tcQual pREL_BASE_Name SLIT("[]") listTyConKey -nilDataConName = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey -consDataConName = dataQual pREL_BASE_Name SLIT(":") consDataConKey - --- Generics -crossTyConName = tcQual pREL_BASE_Name SLIT(":*:") crossTyConKey -crossDataConName = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey -plusTyConName = tcQual pREL_BASE_Name SLIT(":+:") plusTyConKey -inlDataConName = dataQual pREL_BASE_Name SLIT("Inl") inlDataConKey -inrDataConName = dataQual pREL_BASE_Name SLIT("Inr") inrDataConKey -genUnitTyConName = tcQual pREL_BASE_Name SLIT("Unit") genUnitTyConKey -genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey - --- Random PrelBase functions -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 - --- Strings -unpackCStringName = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey -unpackCStringAppendName = varQual pREL_BASE_Name SLIT("unpackAppendCString#") unpackCStringAppendIdKey -unpackCStringFoldrName = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") unpackCStringFoldrIdKey -unpackCStringUtf8Name = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey - --- Classes Eq and Ord -eqClassName = clsQual pREL_BASE_Name SLIT("Eq") eqClassKey -ordClassName = clsQual pREL_BASE_Name SLIT("Ord") ordClassKey -eqName = varQual pREL_BASE_Name SLIT("==") eqClassOpKey -geName = varQual pREL_BASE_Name SLIT(">=") geClassOpKey - --- Class Monad -monadClassName = clsQual pREL_BASE_Name SLIT("Monad") monadClassKey -monadPlusClassName = clsQual pREL_BASE_Name SLIT("MonadPlus") monadPlusClassKey -thenMName = varQual pREL_BASE_Name SLIT(">>=") thenMClassOpKey -returnMName = varQual pREL_BASE_Name SLIT("return") returnMClassOpKey -failMName = varQual pREL_BASE_Name SLIT("fail") failMClassOpKey - --- Class Functor -functorClassName = clsQual pREL_BASE_Name SLIT("Functor") functorClassKey - --- Class Show -showClassName = clsQual pREL_SHOW_Name SLIT("Show") showClassKey - --- Class Read -readClassName = clsQual pREL_READ_Name SLIT("Read") readClassKey +main_RDR_Unqual = mkUnqual varName FSLIT("main") + -- We definitely don't want an Orig RdrName, because + -- main might, in principle, be imported into module Main --- 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 -plusIntegerName = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey -timesIntegerName = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey -integerTyConName = tcQual pREL_NUM_Name SLIT("Integer") integerTyConKey -smallIntegerDataConName = dataQual pREL_NUM_Name SLIT("S#") smallIntegerDataConKey -largeIntegerDataConName = dataQual pREL_NUM_Name SLIT("J#") largeIntegerDataConKey - --- PrelReal types and classes -rationalTyConName = tcQual pREL_REAL_Name SLIT("Rational") rationalTyConKey -ratioTyConName = tcQual pREL_REAL_Name SLIT("Ratio") ratioTyConKey -ratioDataConName = dataQual pREL_REAL_Name SLIT(":%") ratioDataConKey -realClassName = clsQual pREL_REAL_Name SLIT("Real") realClassKey -integralClassName = clsQual pREL_REAL_Name SLIT("Integral") integralClassKey -realFracClassName = clsQual pREL_REAL_Name SLIT("RealFrac") realFracClassKey -fractionalClassName = clsQual pREL_REAL_Name SLIT("Fractional") fractionalClassKey -fromRationalName = varQual pREL_REAL_Name SLIT("fromRational") fromRationalClassOpKey - --- PrelFloat classes -floatTyConName = tcQual pREL_FLOAT_Name SLIT("Float") floatTyConKey -floatDataConName = dataQual pREL_FLOAT_Name SLIT("F#") floatDataConKey -doubleTyConName = tcQual pREL_FLOAT_Name SLIT("Double") doubleTyConKey -doubleDataConName = dataQual pREL_FLOAT_Name SLIT("D#") doubleDataConKey -floatingClassName = clsQual pREL_FLOAT_Name SLIT("Floating") floatingClassKey -realFloatClassName = clsQual pREL_FLOAT_Name SLIT("RealFloat") realFloatClassKey - --- Class Ix -ixClassName = clsQual pREL_ARR_Name SLIT("Ix") ixClassKey - --- Class Enum -enumClassName = clsQual pREL_ENUM_Name SLIT("Enum") enumClassKey -toEnumName = varQual pREL_ENUM_Name SLIT("toEnum") toEnumClassOpKey -fromEnumName = varQual pREL_ENUM_Name SLIT("fromEnum") fromEnumClassOpKey -enumFromName = varQual pREL_ENUM_Name SLIT("enumFrom") enumFromClassOpKey -enumFromToName = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpKey -enumFromThenName = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey -enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey - --- Class Bounded -boundedClassName = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey - --- List functions -concatName = varQual pREL_LIST_Name SLIT("concat") concatIdKey -filterName = varQual pREL_LIST_Name SLIT("filter") filterIdKey -zipName = varQual pREL_LIST_Name SLIT("zip") zipIdKey - --- 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 - --- 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 - -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 - -addrTyConName = tcQual pREL_ADDR_Name SLIT("Addr") addrTyConKey -addrDataConName = dataQual pREL_ADDR_Name SLIT("A#") addrDataConKey - - --- 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 -stablePtrTyConName = tcQual pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey -stablePtrDataConName = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey -deRefStablePtrName = varQual pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey -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 -\end{code} - -%************************************************************************ -%* * -\subsection{Known names} -%* * -%************************************************************************ - -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} --- 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 -ioTyCon_RDR = nameRdrName ioTyConName -intTyCon_RDR = nameRdrName intTyConName eq_RDR = nameRdrName eqName ge_RDR = nameRdrName geName +ne_RDR = varQual_RDR pREL_BASE FSLIT("/=") +le_RDR = varQual_RDR pREL_BASE FSLIT("<=") +gt_RDR = varQual_RDR pREL_BASE FSLIT(">") +compare_RDR = varQual_RDR pREL_BASE FSLIT("compare") +ltTag_RDR = dataQual_RDR pREL_BASE FSLIT("LT") +eqTag_RDR = dataQual_RDR pREL_BASE FSLIT("EQ") +gtTag_RDR = dataQual_RDR pREL_BASE FSLIT("GT") + +eqClass_RDR = nameRdrName eqClassName numClass_RDR = nameRdrName numClassName ordClass_RDR = nameRdrName ordClassName -map_RDR = nameRdrName mapName -append_RDR = nameRdrName appendName +enumClass_RDR = nameRdrName enumClassName +monadClass_RDR = nameRdrName monadClassName + +map_RDR = varQual_RDR pREL_BASE FSLIT("map") +append_RDR = varQual_RDR pREL_BASE FSLIT("++") + foldr_RDR = nameRdrName foldrName build_RDR = nameRdrName buildName -enumFromTo_RDR = nameRdrName enumFromToName returnM_RDR = nameRdrName returnMName -thenM_RDR = nameRdrName thenMName +bindM_RDR = nameRdrName bindMName 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 + +and_RDR = nameRdrName andName + +left_RDR = nameRdrName leftDataConName +right_RDR = nameRdrName rightDataConName + +fromEnum_RDR = varQual_RDR pREL_ENUM FSLIT("fromEnum") +toEnum_RDR = varQual_RDR pREL_ENUM FSLIT("toEnum") + enumFrom_RDR = nameRdrName enumFromName -mkInt_RDR = nameRdrName intDataConName +enumFromTo_RDR = nameRdrName enumFromToName 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 +addrDataCon_RDR = dataQual_RDR aDDR FSLIT("A#") +wordDataCon_RDR = dataQual_RDR pREL_WORD FSLIT("W#") + bindIO_RDR = nameRdrName bindIOName returnIO_RDR = nameRdrName returnIOName -main_RDR = nameRdrName mainName + fromInteger_RDR = nameRdrName fromIntegerName fromRational_RDR = nameRdrName fromRationalName minus_RDR = nameRdrName minusName +times_RDR = varQual_RDR pREL_NUM FSLIT("*") +plus_RDR = varQual_RDR pREL_NUM FSLIT("+") + +compose_RDR = varQual_RDR pREL_BASE FSLIT(".") + +not_RDR = varQual_RDR pREL_BASE FSLIT("not") +getTag_RDR = varQual_RDR pREL_BASE FSLIT("getTag") +succ_RDR = varQual_RDR pREL_ENUM FSLIT("succ") +pred_RDR = varQual_RDR pREL_ENUM FSLIT("pred") +minBound_RDR = varQual_RDR pREL_ENUM FSLIT("minBound") +maxBound_RDR = varQual_RDR pREL_ENUM FSLIT("maxBound") +range_RDR = varQual_RDR pREL_ARR FSLIT("range") +inRange_RDR = varQual_RDR pREL_ARR FSLIT("inRange") +index_RDR = varQual_RDR pREL_ARR FSLIT("index") + +readList_RDR = varQual_RDR pREL_READ FSLIT("readList") +readListDefault_RDR = varQual_RDR pREL_READ FSLIT("readListDefault") +readListPrec_RDR = varQual_RDR pREL_READ FSLIT("readListPrec") +readListPrecDefault_RDR = varQual_RDR pREL_READ FSLIT("readListPrecDefault") +readPrec_RDR = varQual_RDR pREL_READ FSLIT("readPrec") +parens_RDR = varQual_RDR pREL_READ FSLIT("parens") +choose_RDR = varQual_RDR pREL_READ FSLIT("choose") +lexP_RDR = varQual_RDR pREL_READ FSLIT("lexP") + +punc_RDR = dataQual_RDR lEX FSLIT("Punc") +ident_RDR = dataQual_RDR lEX FSLIT("Ident") +symbol_RDR = dataQual_RDR lEX FSLIT("Symbol") + +step_RDR = varQual_RDR rEAD_PREC FSLIT("step") +alt_RDR = varQual_RDR rEAD_PREC FSLIT("+++") +reset_RDR = varQual_RDR rEAD_PREC FSLIT("reset") +prec_RDR = varQual_RDR rEAD_PREC FSLIT("prec") + +showList_RDR = varQual_RDR pREL_SHOW FSLIT("showList") +showList___RDR = varQual_RDR pREL_SHOW FSLIT("showList__") +showsPrec_RDR = varQual_RDR pREL_SHOW FSLIT("showsPrec") +showString_RDR = varQual_RDR pREL_SHOW FSLIT("showString") +showSpace_RDR = varQual_RDR pREL_SHOW FSLIT("showSpace") +showParen_RDR = varQual_RDR pREL_SHOW FSLIT("showParen") + +typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf") +mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp") +mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon") + +undefined_RDR = varQual_RDR pREL_ERR FSLIT("undefined") + +crossDataCon_RDR = dataQual_RDR pREL_BASE FSLIT(":*:") +inlDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Inl") +inrDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Inr") +genUnitDataCon_RDR = dataQual_RDR pREL_BASE FSLIT("Unit") + +---------------------- +varQual_RDR mod str = mkOrig mod (mkOccFS varName str) +tcQual_RDR mod str = mkOrig mod (mkOccFS tcName str) +clsQual_RDR mod str = mkOrig mod (mkOccFS clsName str) +dataQual_RDR mod str = mkOrig mod (mkOccFS dataName str) +\end{code} + +%************************************************************************ +%* * +\subsection{Known-key names} +%* * +%************************************************************************ + +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. + +--MetaHaskell Extension add the constrs and the lower case case +-- guys as well (perhaps) e.g. see trueDataConName below + + +\begin{code} +rootMainName = varQual rOOT_MAIN FSLIT("main") rootMainKey +runMainIOName = varQual pREL_TOP_HANDLER FSLIT("runMainIO") runMainKey + +orderingTyConName = tcQual pREL_BASE FSLIT("Ordering") orderingTyConKey + +eitherTyConName = tcQual pREL_EITHER FSLIT("Either") eitherTyConKey +leftDataConName = conName eitherTyConName FSLIT("Left") leftDataConKey +rightDataConName = conName eitherTyConName FSLIT("Right") rightDataConKey + +-- Generics +crossTyConName = tcQual pREL_BASE FSLIT(":*:") crossTyConKey +plusTyConName = tcQual pREL_BASE FSLIT(":+:") plusTyConKey +genUnitTyConName = tcQual pREL_BASE FSLIT("Unit") genUnitTyConKey + +-- Base strings Strings +unpackCStringName = varQual pREL_BASE FSLIT("unpackCString#") unpackCStringIdKey +unpackCStringAppendName = varQual pREL_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey +unpackCStringFoldrName = varQual pREL_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey +unpackCStringUtf8Name = varQual pREL_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey +eqStringName = varQual pREL_BASE FSLIT("eqString") eqStringIdKey + +-- Base classes (Eq, Ord, Functor) +eqClassName = clsQual pREL_BASE FSLIT("Eq") eqClassKey +eqName = methName eqClassName FSLIT("==") eqClassOpKey +ordClassName = clsQual pREL_BASE FSLIT("Ord") ordClassKey +geName = methName ordClassName FSLIT(">=") geClassOpKey +functorClassName = clsQual pREL_BASE FSLIT("Functor") functorClassKey + +-- Class Monad +monadClassName = clsQual pREL_BASE FSLIT("Monad") monadClassKey +thenMName = methName monadClassName FSLIT(">>") thenMClassOpKey +bindMName = methName monadClassName FSLIT(">>=") bindMClassOpKey +returnMName = methName monadClassName FSLIT("return") returnMClassOpKey +failMName = methName monadClassName FSLIT("fail") failMClassOpKey + +-- Random PrelBase functions +otherwiseIdName = varQual pREL_BASE FSLIT("otherwise") otherwiseIdKey +foldrName = varQual pREL_BASE FSLIT("foldr") foldrIdKey +buildName = varQual pREL_BASE FSLIT("build") buildIdKey +augmentName = varQual pREL_BASE FSLIT("augment") augmentIdKey +appendName = varQual pREL_BASE FSLIT("++") appendIdKey +andName = varQual pREL_BASE FSLIT("&&") andIdKey +orName = varQual pREL_BASE FSLIT("||") orIdKey +assertName = varQual pREL_BASE FSLIT("assert") assertIdKey + +-- PrelTup +fstName = varQual pREL_TUP FSLIT("fst") fstIdKey +sndName = varQual pREL_TUP FSLIT("snd") sndIdKey + +-- Module PrelNum +numClassName = clsQual pREL_NUM FSLIT("Num") numClassKey +fromIntegerName = methName numClassName FSLIT("fromInteger") fromIntegerClassOpKey +minusName = methName numClassName FSLIT("-") minusClassOpKey +negateName = methName numClassName FSLIT("negate") negateClassOpKey +plusIntegerName = varQual pREL_NUM FSLIT("plusInteger") plusIntegerIdKey +timesIntegerName = varQual pREL_NUM FSLIT("timesInteger") timesIntegerIdKey +integerTyConName = tcQual pREL_NUM FSLIT("Integer") integerTyConKey +smallIntegerDataConName = conName integerTyConName FSLIT("S#") smallIntegerDataConKey +largeIntegerDataConName = conName integerTyConName FSLIT("J#") largeIntegerDataConKey + +-- PrelReal types and classes +rationalTyConName = tcQual pREL_REAL FSLIT("Rational") rationalTyConKey +ratioTyConName = tcQual pREL_REAL FSLIT("Ratio") ratioTyConKey +ratioDataConName = conName ratioTyConName FSLIT(":%") ratioDataConKey +realClassName = clsQual pREL_REAL FSLIT("Real") realClassKey +integralClassName = clsQual pREL_REAL FSLIT("Integral") integralClassKey +realFracClassName = clsQual pREL_REAL FSLIT("RealFrac") realFracClassKey +fractionalClassName = clsQual pREL_REAL FSLIT("Fractional") fractionalClassKey +fromRationalName = methName fractionalClassName FSLIT("fromRational") fromRationalClassOpKey + +-- PrelFloat classes +floatingClassName = clsQual pREL_FLOAT FSLIT("Floating") floatingClassKey +realFloatClassName = clsQual pREL_FLOAT FSLIT("RealFloat") realFloatClassKey + +-- Class Ix +ixClassName = clsQual pREL_ARR FSLIT("Ix") ixClassKey + +-- Class Typeable +typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey +typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey +typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey +typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey +typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey +typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey +typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey +typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey + +typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName + , typeable3ClassName, typeable4ClassName, typeable5ClassName + , typeable6ClassName, typeable7ClassName ] + +-- Class Data +dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey + +-- Error module +assertErrorName = varQual pREL_ERR FSLIT("assertError") assertErrorIdKey + +-- Enum module (Enum, Bounded) +enumClassName = clsQual pREL_ENUM FSLIT("Enum") enumClassKey +enumFromName = methName enumClassName FSLIT("enumFrom") enumFromClassOpKey +enumFromToName = methName enumClassName FSLIT("enumFromTo") enumFromToClassOpKey +enumFromThenName = methName enumClassName FSLIT("enumFromThen") enumFromThenClassOpKey +enumFromThenToName = methName enumClassName FSLIT("enumFromThenTo") enumFromThenToClassOpKey +boundedClassName = clsQual pREL_ENUM FSLIT("Bounded") boundedClassKey + +-- List functions +concatName = varQual pREL_LIST FSLIT("concat") concatIdKey +filterName = varQual pREL_LIST FSLIT("filter") filterIdKey +zipName = varQual pREL_LIST FSLIT("zip") zipIdKey + +-- Class Show +showClassName = clsQual pREL_SHOW FSLIT("Show") showClassKey + +-- Class Read +readClassName = clsQual pREL_READ FSLIT("Read") readClassKey + +-- parallel array types and functions +enumFromToPName = varQual pREL_PARR FSLIT("enumFromToP") enumFromToPIdKey +enumFromThenToPName= varQual pREL_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey +nullPName = varQual pREL_PARR FSLIT("nullP") nullPIdKey +lengthPName = varQual pREL_PARR FSLIT("lengthP") lengthPIdKey +replicatePName = varQual pREL_PARR FSLIT("replicateP") replicatePIdKey +mapPName = varQual pREL_PARR FSLIT("mapP") mapPIdKey +filterPName = varQual pREL_PARR FSLIT("filterP") filterPIdKey +zipPName = varQual pREL_PARR FSLIT("zipP") zipPIdKey +crossPName = varQual pREL_PARR FSLIT("crossP") crossPIdKey +indexPName = varQual pREL_PARR FSLIT("!:") indexPIdKey +toPName = varQual pREL_PARR FSLIT("toP") toPIdKey +bpermutePName = varQual pREL_PARR FSLIT("bpermuteP") bpermutePIdKey +bpermuteDftPName = varQual pREL_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey +indexOfPName = varQual pREL_PARR FSLIT("indexOfP") indexOfPIdKey + +-- IOBase things +ioTyConName = tcQual pREL_IO_BASE FSLIT("IO") ioTyConKey +ioDataConName = conName ioTyConName FSLIT("IO") ioDataConKey +thenIOName = varQual pREL_IO_BASE FSLIT("thenIO") thenIOIdKey +bindIOName = varQual pREL_IO_BASE FSLIT("bindIO") bindIOIdKey +returnIOName = varQual pREL_IO_BASE FSLIT("returnIO") returnIOIdKey +failIOName = varQual pREL_IO_BASE FSLIT("failIO") failIOIdKey + +-- IO things +printName = varQual sYSTEM_IO FSLIT("print") printIdKey + +-- Int, Word, and Addr things +int8TyConName = tcQual pREL_INT FSLIT("Int8") int8TyConKey +int16TyConName = tcQual pREL_INT FSLIT("Int16") int16TyConKey +int32TyConName = tcQual pREL_INT FSLIT("Int32") int32TyConKey +int64TyConName = tcQual pREL_INT FSLIT("Int64") int64TyConKey + +-- Word module +word8TyConName = tcQual pREL_WORD FSLIT("Word8") word8TyConKey +word16TyConName = tcQual pREL_WORD FSLIT("Word16") word16TyConKey +word32TyConName = tcQual pREL_WORD FSLIT("Word32") word32TyConKey +word64TyConName = tcQual pREL_WORD FSLIT("Word64") word64TyConKey +wordTyConName = tcQual pREL_WORD FSLIT("Word") wordTyConKey +wordDataConName = conName wordTyConName FSLIT("W#") wordDataConKey + +-- Addr module +addrTyConName = tcQual aDDR FSLIT("Addr") addrTyConKey + +-- PrelPtr module +ptrTyConName = tcQual pREL_PTR FSLIT("Ptr") ptrTyConKey +funPtrTyConName = tcQual pREL_PTR FSLIT("FunPtr") funPtrTyConKey + +-- Byte array types +byteArrayTyConName = tcQual pREL_BYTEARR FSLIT("ByteArray") byteArrayTyConKey +mutableByteArrayTyConName = tcQual pREL_BYTEARR FSLIT("MutableByteArray") mutableByteArrayTyConKey + +-- Foreign objects and weak pointers +stablePtrTyConName = tcQual pREL_STABLE FSLIT("StablePtr") stablePtrTyConKey +newStablePtrName = varQual pREL_STABLE FSLIT("newStablePtr") newStablePtrIdKey + +-- PrelST module +runSTRepName = varQual pREL_ST FSLIT("runSTRep") runSTRepIdKey + +-- The "split" Id for splittable implicit parameters +splittableClassName = clsQual gLA_EXTS FSLIT("Splittable") splittableClassKey +splitName = methName splittableClassName FSLIT("split") splitIdKey + +-- Recursive-do notation +monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey +mfixName = methName monadFixClassName FSLIT("mfix") mfixIdKey + +-- Arrow notation +arrAName = varQual aRROW FSLIT("arr") arrAIdKey +composeAName = varQual aRROW FSLIT(">>>") composeAIdKey +firstAName = varQual aRROW FSLIT("first") firstAIdKey +appAName = varQual aRROW FSLIT("app") appAIdKey +choiceAName = varQual aRROW FSLIT("|||") choiceAIdKey +loopAName = varQual aRROW FSLIT("loop") loopAIdKey + +-- dotnet interop +objectTyConName = tcQual dOTNET FSLIT("Object") objectTyConKey + -- objectTyConName was "wTcQual", but that's gone now, and + -- I can't see why it was wired in anyway... +unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey +marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey +marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey +unmarshalStringName = varQual dOTNET FSLIT("unmarshalString") unmarshalStringIdKey +checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNameIdKey \end{code} %************************************************************************ @@ -563,19 +642,23 @@ minus_RDR = nameRdrName minusName All these are original names; hence mkOrig \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 = mkKnownKeyGlobal (mkRdrOrig pREL_GHC_Name (mkKindOccFS tcName str)) uq - -- Kinds are not z-encoded in interface file, hence mkKindOccFS - -- And they all come from PrelGHC - -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 +varQual = mk_known_key_name varName +tcQual = mk_known_key_name tcName +clsQual = mk_known_key_name clsName + +mk_known_key_name space mod str uniq + = mkExternalName uniq mod (mkOccFS space str) + Nothing noSrcLoc + +conName :: Name -> FastString -> Unique -> Name +conName tycon occ uniq + = mkExternalName uniq (nameModule tycon) (mkOccFS dataName occ) + (Just tycon) noSrcLoc + +methName :: Name -> FastString -> Unique -> Name +methName cls occ uniq + = mkExternalName uniq (nameModule cls) (mkOccFS varName occ) + (Just cls) noSrcLoc \end{code} %************************************************************************ @@ -583,6 +666,7 @@ dataQual_RDR mod str = mkOrig dataName mod str \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@} %* * %************************************************************************ +--MetaHaskell extension hand allocate keys here \begin{code} boundedClassKey = mkPreludeClassUnique 1 @@ -592,7 +676,7 @@ floatingClassKey = mkPreludeClassUnique 5 fractionalClassKey = mkPreludeClassUnique 6 integralClassKey = mkPreludeClassUnique 7 monadClassKey = mkPreludeClassUnique 8 -monadPlusClassKey = mkPreludeClassUnique 9 +dataClassKey = mkPreludeClassUnique 9 functorClassKey = mkPreludeClassUnique 10 numClassKey = mkPreludeClassUnique 11 ordClassKey = mkPreludeClassUnique 12 @@ -601,11 +685,19 @@ realClassKey = mkPreludeClassUnique 14 realFloatClassKey = mkPreludeClassUnique 15 realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 - -cCallableClassKey = mkPreludeClassUnique 18 -cReturnableClassKey = mkPreludeClassUnique 19 - -ixClassKey = mkPreludeClassUnique 20 +ixClassKey = mkPreludeClassUnique 18 + +typeableClassKey = mkPreludeClassUnique 20 +typeable1ClassKey = mkPreludeClassUnique 21 +typeable2ClassKey = mkPreludeClassUnique 22 +typeable3ClassKey = mkPreludeClassUnique 23 +typeable4ClassKey = mkPreludeClassUnique 24 +typeable5ClassKey = mkPreludeClassUnique 25 +typeable6ClassKey = mkPreludeClassUnique 26 +typeable7ClassKey = mkPreludeClassUnique 27 + +monadFixClassKey = mkPreludeClassUnique 28 +splittableClassKey = mkPreludeClassUnique 29 \end{code} %************************************************************************ @@ -631,55 +723,68 @@ 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 - --- Usage type constructors -usageConKey = mkPreludeTyConUnique 72 -usOnceTyConKey = mkPreludeTyConUnique 73 -usManyTyConKey = mkPreludeTyConUnique 74 +int32PrimTyConKey = mkPreludeTyConUnique 18 +int32TyConKey = mkPreludeTyConUnique 19 +int64PrimTyConKey = mkPreludeTyConUnique 20 +int64TyConKey = mkPreludeTyConUnique 21 +integerTyConKey = mkPreludeTyConUnique 22 +listTyConKey = mkPreludeTyConUnique 23 +foreignObjPrimTyConKey = mkPreludeTyConUnique 24 +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 +tVarPrimTyConKey = mkPreludeTyConUnique 76 -- Generic Type Constructors -crossTyConKey = mkPreludeTyConUnique 75 -plusTyConKey = mkPreludeTyConUnique 76 -genUnitTyConKey = mkPreludeTyConUnique 77 +crossTyConKey = mkPreludeTyConUnique 79 +plusTyConKey = mkPreludeTyConUnique 80 +genUnitTyConKey = mkPreludeTyConUnique 81 + +-- Parallel array type constructor +parrTyConKey = mkPreludeTyConUnique 82 + +-- dotnet interop +objectTyConKey = mkPreludeTyConUnique 83 + +eitherTyConKey = mkPreludeTyConUnique 84 + +---------------- Template Haskell ------------------- +-- USES TyConUniques 100-129 +----------------------------------------------------- + +unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} %************************************************************************ @@ -689,7 +794,6 @@ genUnitTyConKey = mkPreludeTyConUnique 77 %************************************************************************ \begin{code} -addrDataConKey = mkPreludeDataConUnique 0 charDataConKey = mkPreludeDataConUnique 1 consDataConKey = mkPreludeDataConUnique 2 doubleDataConKey = mkPreludeDataConUnique 3 @@ -698,20 +802,24 @@ floatDataConKey = mkPreludeDataConUnique 5 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 +nilDataConKey = mkPreludeDataConUnique 11 +ratioDataConKey = mkPreludeDataConUnique 12 +stableNameDataConKey = mkPreludeDataConUnique 14 +trueDataConKey = mkPreludeDataConUnique 15 +wordDataConKey = mkPreludeDataConUnique 16 +ioDataConKey = mkPreludeDataConUnique 17 -- 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 + +leftDataConKey = mkPreludeDataConUnique 25 +rightDataConKey = mkPreludeDataConUnique 26 \end{code} %************************************************************************ @@ -722,34 +830,36 @@ genUnitDataConKey = mkPreludeDataConUnique 20 \begin{code} absentErrorIdKey = mkPreludeMiscIdUnique 1 -appendIdKey = mkPreludeMiscIdUnique 2 augmentIdKey = mkPreludeMiscIdUnique 3 -buildIdKey = mkPreludeMiscIdUnique 4 -errorIdKey = mkPreludeMiscIdUnique 5 -foldlIdKey = mkPreludeMiscIdUnique 6 -foldrIdKey = mkPreludeMiscIdUnique 7 -recSelErrIdKey = mkPreludeMiscIdUnique 8 -integerMinusOneIdKey = mkPreludeMiscIdUnique 9 -integerPlusOneIdKey = mkPreludeMiscIdUnique 10 -integerPlusTwoIdKey = mkPreludeMiscIdUnique 11 -integerZeroIdKey = mkPreludeMiscIdUnique 12 -int2IntegerIdKey = mkPreludeMiscIdUnique 13 -irrefutPatErrorIdKey = mkPreludeMiscIdUnique 15 -eqStringIdKey = mkPreludeMiscIdUnique 16 -noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 17 -nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18 -parErrorIdKey = mkPreludeMiscIdUnique 20 -parIdKey = mkPreludeMiscIdUnique 21 -patErrorIdKey = mkPreludeMiscIdUnique 22 -realWorldPrimIdKey = mkPreludeMiscIdUnique 23 -recConErrorIdKey = mkPreludeMiscIdUnique 24 -recUpdErrorIdKey = mkPreludeMiscIdUnique 25 -traceIdKey = mkPreludeMiscIdUnique 26 -unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 27 -unpackCStringAppendIdKey = mkPreludeMiscIdUnique 28 -unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 29 -unpackCStringIdKey = mkPreludeMiscIdUnique 30 -ushowListIdKey = mkPreludeMiscIdUnique 31 +appendIdKey = mkPreludeMiscIdUnique 4 +buildIdKey = mkPreludeMiscIdUnique 5 +errorIdKey = mkPreludeMiscIdUnique 6 +foldlIdKey = mkPreludeMiscIdUnique 7 +foldrIdKey = mkPreludeMiscIdUnique 8 +recSelErrorIdKey = mkPreludeMiscIdUnique 9 +integerMinusOneIdKey = mkPreludeMiscIdUnique 10 +integerPlusOneIdKey = mkPreludeMiscIdUnique 11 +integerPlusTwoIdKey = mkPreludeMiscIdUnique 12 +integerZeroIdKey = mkPreludeMiscIdUnique 13 +int2IntegerIdKey = mkPreludeMiscIdUnique 14 +seqIdKey = mkPreludeMiscIdUnique 15 +irrefutPatErrorIdKey = mkPreludeMiscIdUnique 16 +eqStringIdKey = mkPreludeMiscIdUnique 17 +noMethodBindingErrorIdKey = mkPreludeMiscIdUnique 18 +nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19 +runtimeErrorIdKey = mkPreludeMiscIdUnique 20 +parErrorIdKey = mkPreludeMiscIdUnique 21 +parIdKey = mkPreludeMiscIdUnique 22 +patErrorIdKey = mkPreludeMiscIdUnique 23 +realWorldPrimIdKey = mkPreludeMiscIdUnique 24 +recConErrorIdKey = mkPreludeMiscIdUnique 25 +recUpdErrorIdKey = mkPreludeMiscIdUnique 26 +traceIdKey = mkPreludeMiscIdUnique 27 +unpackCStringUtf8IdKey = mkPreludeMiscIdUnique 28 +unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29 +unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30 +unpackCStringIdKey = mkPreludeMiscIdUnique 31 + unsafeCoerceIdKey = mkPreludeMiscIdUnique 32 concatIdKey = mkPreludeMiscIdUnique 33 filterIdKey = mkPreludeMiscIdUnique 34 @@ -758,9 +868,51 @@ bindIOIdKey = mkPreludeMiscIdUnique 36 returnIOIdKey = mkPreludeMiscIdUnique 37 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 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 +assertIdKey = mkPreludeMiscIdUnique 53 +runSTRepIdKey = mkPreludeMiscIdUnique 54 + +rootMainKey = mkPreludeMiscIdUnique 55 +runMainKey = mkPreludeMiscIdUnique 56 + +andIdKey = mkPreludeMiscIdUnique 57 +orIdKey = mkPreludeMiscIdUnique 58 +thenIOIdKey = mkPreludeMiscIdUnique 59 +lazyIdKey = mkPreludeMiscIdUnique 60 +assertErrorIdKey = mkPreludeMiscIdUnique 61 + +-- Parallel array functions +nullPIdKey = mkPreludeMiscIdUnique 80 +lengthPIdKey = mkPreludeMiscIdUnique 81 +replicatePIdKey = mkPreludeMiscIdUnique 82 +mapPIdKey = mkPreludeMiscIdUnique 83 +filterPIdKey = mkPreludeMiscIdUnique 84 +zipPIdKey = mkPreludeMiscIdUnique 85 +crossPIdKey = mkPreludeMiscIdUnique 86 +indexPIdKey = mkPreludeMiscIdUnique 87 +toPIdKey = mkPreludeMiscIdUnique 88 +enumFromToPIdKey = mkPreludeMiscIdUnique 89 +enumFromThenToPIdKey = mkPreludeMiscIdUnique 90 +bpermutePIdKey = mkPreludeMiscIdUnique 91 +bpermuteDftPIdKey = mkPreludeMiscIdUnique 92 +indexOfPIdKey = mkPreludeMiscIdUnique 93 + +-- dotnet interop +unmarshalObjectIdKey = mkPreludeMiscIdUnique 94 +marshalObjectIdKey = mkPreludeMiscIdUnique 95 +marshalStringIdKey = mkPreludeMiscIdUnique 96 +unmarshalStringIdKey = mkPreludeMiscIdUnique 97 +checkDotnetResNameIdKey = mkPreludeMiscIdUnique 98 + \end{code} Certain class operations from Prelude classes. They get their own @@ -768,7 +920,9 @@ 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 @@ -778,22 +932,26 @@ 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 +bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) +thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>) returnMClassOpKey = mkPreludeMiscIdUnique 117 -otherwiseIdKey = mkPreludeMiscIdUnique 118 -toEnumClassOpKey = mkPreludeMiscIdUnique 119 -mapIdKey = mkPreludeMiscIdUnique 120 -\end{code} -\begin{code} -assertIdKey = mkPreludeMiscIdUnique 121 -runSTRepIdKey = mkPreludeMiscIdUnique 122 +-- Recursive do notation +mfixIdKey = mkPreludeMiscIdUnique 118 + +-- Arrow notation +arrAIdKey = mkPreludeMiscIdUnique 119 +composeAIdKey = mkPreludeMiscIdUnique 120 -- >>> +firstAIdKey = mkPreludeMiscIdUnique 121 +appAIdKey = mkPreludeMiscIdUnique 122 +choiceAIdKey = mkPreludeMiscIdUnique 123 -- ||| +loopAIdKey = mkPreludeMiscIdUnique 124 + +---------------- Template Haskell ------------------- +-- USES IdUniques 200-399 +----------------------------------------------------- \end{code} @@ -820,7 +978,6 @@ cCallishTyKeys = , wordTyConKey , byteArrayTyConKey , mutableByteArrayTyConKey - , foreignObjTyConKey , stablePtrTyConKey , int8TyConKey , int16TyConKey @@ -840,62 +997,6 @@ cCallishTyKeys = %* * %************************************************************************ -@derivableClassKeys@ is also used in checking \tr{deriving} constructs -(@TcDeriv@). - -@derivingOccurrences@ maps a class name to a list of the (qualified) -occurrences that will be mentioned by the derived code for the class -when it is later generated. We don't need to put in things that are -WiredIn (because they are already mapped to their correct name by the -@NameSupply@. The class itself, and all its class ops, is already -flagged as an occurrence so we don't need to mention that either. - -@derivingOccurrences@ has an item for every derivable class, even if -that item is empty, because we treat lookup failure as indicating that -the class is illegal in a deriving clause. - -\begin{code} -derivingOccurrences :: UniqFM [RdrName] -derivingOccurrences = listToUFM deriving_occ_info - -derivableClassKeys = map fst deriving_occ_info - -deriving_occ_info - = [ (eqClassKey, [intTyCon_RDR, and_RDR, not_RDR]) - , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR]) - -- EQ (from Ordering) is needed to force in the constructors - -- as well as the type constructor. - , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR]) - -- The last two Enum deps are only used to produce better - -- error msgs for derived toEnum methods. - , (boundedClassKey, [intTyCon_RDR]) - , (showClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR, - showParen_RDR, showSpace_RDR, showList___RDR]) - , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR, - foldr_RDR, build_RDR, - -- foldr and build required for list comprehension - -- KSW 2000-06 - lex_RDR, readParen_RDR, readList___RDR, thenM_RDR]) - -- returnM (and the rest of the Monad class decl) - -- will be forced in as result of depending - -- on thenM. -- SOF 1/99 - , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR, - foldr_RDR, build_RDR, - -- foldr and build required for list comprehension used - -- with single constructor types -- KSW 2000-06 - returnM_RDR, failM_RDR]) - -- the last two are needed to force returnM, thenM and failM - -- in before typechecking the list(monad) comprehension - -- generated for derived Ix instances (range method) - -- of single constructor types. -- SOF 8/97 - ] - -- intTyCon: Practically any deriving needs Int, either for index calculations, - -- or for taggery. - -- ordClass: really it's the methods that are actually used. - -- numClass: for Int literals -\end{code} - - NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@ even though every numeric class has these two as a superclass, because the list of ambiguous dictionaries hasn't been simplified. @@ -921,32 +1022,17 @@ needsDataDeclCtxtClassKeys = -- see comments in TcDeriv [ readClassKey ] -cCallishClassKeys = - [ cCallableClassKey - , cReturnableClassKey - ] +standardClassKeys = derivableClassKeys ++ numericClassKeys -standardClassKeys - = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys - -- - -- We have to have "CCallable" and "CReturnable" in the standard - -- classes, so that if you go... - -- - -- _ccall_ foo ... 93{-numeric literal-} ... - -- - -- ... it can do The Right Thing on the 93. - -noDictClassKeys -- These classes are used only for type annotations; - -- they are not implemented by dictionaries, ever. - = cCallishClassKeys +noDictClassKeys = [] -- ToDo: remove? \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 +@derivableClassKeys@ is also used in checking \tr{deriving} constructs +(@TcDeriv@). -isUnboundName :: Name -> Bool -isUnboundName name = name `hasKey` unboundKey +\begin{code} +derivableClassKeys + = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey, + boundedClassKey, showClassKey, readClassKey ] \end{code} +