X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fprelude%2FPrelInfo.lhs;h=36b9520eefd39026c8ea6a3ca0362aee5542648e;hb=0d197643ea29ae54ed91e51fc890893b2ae5e16c;hp=830247aee6a8ede1798f7a79b81704443fe6379f;hpb=718754ae4f9230b9ecb2e0e47e25e1e101bfe41b;p=ghc-hetmet.git diff --git a/ghc/compiler/prelude/PrelInfo.lhs b/ghc/compiler/prelude/PrelInfo.lhs index 830247a..36b9520 100644 --- a/ghc/compiler/prelude/PrelInfo.lhs +++ b/ghc/compiler/prelude/PrelInfo.lhs @@ -5,96 +5,42 @@ \begin{code} module PrelInfo ( - builtinNames, -- Names of things whose *unique* must be known, but - -- that is all. If something is in here, you know that - -- if it's used at all then it's Name will be just as - -- it is here, unique and all. Includes all the - -- wiredd-in names. - - thinAirIdNames, -- Names of non-wired-in Ids that may be used out of - setThinAirIds, -- thin air in any compilation. If they are not wired in - thinAirModules, -- we must be sure to import them from some Prelude - -- interface file even if they are not overtly - -- mentioned. Subset of builtinNames. - noRepIntegerIds, - noRepStrIds, - - derivingOccurrences, -- For a given class C, this tells what other - -- things are needed as a result of a - -- deriving(C) clause - - - -- Here are the thin-air Ids themselves - int2IntegerId, addr2IntegerId, - integerMinusOneId, integerZeroId, integerPlusOneId, integerPlusTwoId, - packStringForCId, unpackCStringId, unpackCString2Id, - unpackCStringAppendId, unpackCStringFoldrId, - foldrId, + module MkId, + ghcPrimExports, + wiredInThings, basicKnownKeyNames, + primOpId, + -- Random other things - main_NAME, ioTyCon_NAME, - deRefStablePtr_NAME, makeStablePtr_NAME, - bindIO_NAME, - maybeCharLikeCon, maybeIntLikeCon, - needsDataDeclCtxtClassKeys, cCallishClassKeys, cCallishTyKeys, - isNoDictClass, isNumericClass, isStandardClass, isCcallishClass, - isCreturnableClass, numericTyKeys, - - -- RdrNames for lots of things, mainly used in derivings - eq_RDR, ne_RDR, le_RDR, lt_RDR, ge_RDR, gt_RDR, max_RDR, min_RDR, - compare_RDR, minBound_RDR, maxBound_RDR, enumFrom_RDR, enumFromTo_RDR, - enumFromThen_RDR, enumFromThenTo_RDR, succ_RDR, pred_RDR, fromEnum_RDR, toEnum_RDR, - ratioDataCon_RDR, range_RDR, index_RDR, inRange_RDR, readsPrec_RDR, - readList_RDR, showsPrec_RDR, showList_RDR, plus_RDR, times_RDR, - ltTag_RDR, eqTag_RDR, gtTag_RDR, eqH_Char_RDR, ltH_Char_RDR, - eqH_Word_RDR, ltH_Word_RDR, eqH_Addr_RDR, ltH_Addr_RDR, eqH_Float_RDR, - ltH_Float_RDR, eqH_Double_RDR, ltH_Double_RDR, eqH_Int_RDR, - ltH_Int_RDR, geH_RDR, leH_RDR, minusH_RDR, false_RDR, true_RDR, - and_RDR, not_RDR, append_RDR, map_RDR, compose_RDR, mkInt_RDR, - error_RDR, assertErr_RDR, - showString_RDR, showParen_RDR, readParen_RDR, lex_RDR, - showSpace_RDR, showList___RDR, readList___RDR, negate_RDR, - numClass_RDR, fractionalClass_RDR, eqClass_RDR, - ccallableClass_RDR, creturnableClass_RDR, - monadClass_RDR, enumClass_RDR, ordClass_RDR, - ioDataCon_RDR, - - mkTupConRdrName, mkUbxTupConRdrName + -- Class categories + isNoDictClass, isNumericClass, isStandardClass ) where #include "HsVersions.h" +import PrelNames ( basicKnownKeyNames, + hasKey, charDataConKey, intDataConKey, + numericClassKeys, standardClassKeys, + noDictClassKeys ) --- friends: -import PrelMods -- Prelude module names -import PrelVals -- VALUES -import MkId ( mkPrimitiveId ) -import PrimOp ( PrimOp(..), allThePrimOps ) +import PrimOp ( PrimOp, allThePrimOps, primOpOcc, primOpTag, maxPrimOpTag ) import DataCon ( DataCon ) -import PrimRep ( PrimRep(..) ) -import TysPrim -- TYPES -import TysWiredIn - --- others: -import RdrHsSyn ( RdrName(..), varQual, tcQual, qual ) -import BasicTypes ( IfaceFlavour ) -import Var ( varUnique, Id ) -import Name ( Name, OccName, Provenance(..), - getName, mkGlobalName, modAndOcc - ) -import Class ( Class, classKey ) -import TyCon ( tyConDataCons, TyCon ) +import Id ( Id, idName ) +import MkId ( mkPrimOpId, wiredInIds ) +import MkId -- All of it, for re-export +import Name ( nameOccName ) +import TysPrim ( primTyCons ) +import TysWiredIn ( wiredInTyCons ) +import HscTypes ( TyThing(..), implicitTyThings, GenAvailInfo(..), RdrAvailInfo ) +import Class ( Class, classKey ) import Type ( funTyCon ) -import Bag -import Unique -- *Key stuff -import UniqFM ( UniqFM, listToUFM, lookupWithDefaultUFM ) +import TyCon ( tyConName ) import Util ( isIn ) -import Panic ( panic ) -import IOExts +import Array ( Array, array, (!) ) \end{code} %************************************************************************ @@ -107,222 +53,59 @@ We have two ``builtin name funs,'' one to look up @TyCons@ and @Classes@, the other to look up values. \begin{code} -builtinNames :: Bag Name -builtinNames - = unionManyBags - [ -- Wired in TyCons - unionManyBags (map getTyConNames wired_in_tycons) +wiredInThings :: [TyThing] +wiredInThings + = concat + [ -- Wired in TyCons and their implicit Ids + tycon_things + , concatMap implicitTyThings tycon_things -- Wired in Ids - , listToBag (map getName wired_in_ids) + , map AnId wiredInIds -- PrimOps - , listToBag (map (getName . mkPrimitiveId) allThePrimOps) - - -- Thin-air ids - , listToBag thinAirIdNames - - -- Other names with magic keys - , listToBag knownKeyNames - ] -\end{code} - - -\begin{code} -getTyConNames :: TyCon -> Bag Name -getTyConNames tycon - = getName tycon `consBag` - listToBag (map getName (tyConDataCons tycon)) - -- Synonyms return empty list of constructors + , map (AnId . mkPrimOpId) allThePrimOps + ] + where + tycon_things = map ATyCon ([funTyCon] ++ primTyCons ++ wiredInTyCons) \end{code} We let a lot of "non-standard" values be visible, so that we can make sense of them in interface pragmas. It's cool, though they all have "non-standard" names, so they won't get past the parser in user code. - %************************************************************************ %* * -\subsection{Wired in TyCons} + PrimOpIds %* * %************************************************************************ \begin{code} -wired_in_tycons = [funTyCon] ++ - prim_tycons ++ - tuple_tycons ++ - unboxed_tuple_tycons ++ - data_tycons - -prim_tycons - = [ addrPrimTyCon - , arrayPrimTyCon - , byteArrayPrimTyCon - , charPrimTyCon - , doublePrimTyCon - , floatPrimTyCon - , intPrimTyCon - , int64PrimTyCon - , foreignObjPrimTyCon - , weakPrimTyCon - , mutableArrayPrimTyCon - , mutableByteArrayPrimTyCon - , mVarPrimTyCon - , mutVarPrimTyCon - , realWorldTyCon - , stablePtrPrimTyCon - , statePrimTyCon - , threadIdPrimTyCon - , wordPrimTyCon - , word64PrimTyCon - ] +primOpIds :: Array Int Id -- Indexed by PrimOp tag +primOpIds = array (1,maxPrimOpTag) [ (primOpTag op, mkPrimOpId op) + | op <- allThePrimOps] -tuple_tycons = unitTyCon : [tupleTyCon i | i <- [2..37] ] -unboxed_tuple_tycons = [unboxedTupleTyCon i | i <- [1..37] ] - -data_tycons - = [ addrTyCon - , boolTyCon - , charTyCon - , doubleTyCon - , floatTyCon - , intTyCon - , int8TyCon - , int16TyCon - , int32TyCon - , int64TyCon - , integerTyCon - , listTyCon - , wordTyCon - , word8TyCon - , word16TyCon - , word32TyCon - , word64TyCon - ] +primOpId :: PrimOp -> Id +primOpId op = primOpIds ! primOpTag op \end{code} %************************************************************************ %* * -\subsection{Wired in Ids} -%* * -%************************************************************************ - -\begin{code} -wired_in_ids - = [ -- These error-y things are wired in because we don't yet have - -- a way to express in an interface file that the result type variable - -- is 'open'; that is can be unified with an unboxed type - -- - -- [The interface file format now carry such information, but there's - -- no way yet of expressing at the definition site for these error-reporting - -- functions that they have an 'open' result type. -- sof 1/99] - -- - aBSENT_ERROR_ID - , eRROR_ID - , iRREFUT_PAT_ERROR_ID - , nON_EXHAUSTIVE_GUARDS_ERROR_ID - , nO_METHOD_BINDING_ERROR_ID - , pAR_ERROR_ID - , pAT_ERROR_ID - , rEC_CON_ERROR_ID - , rEC_UPD_ERROR_ID - - -- These two can't be defined in Haskell - , realWorldPrimId - , unsafeCoerceId - ] - -\end{code} - -%************************************************************************ -%* * -\subsection{Thin air entities} +\subsection{Export lists for pseudo-modules (GHC.Prim)} %* * %************************************************************************ -These are Ids that we need to reference in various parts of the -system, and we'd like to pull them out of thin air rather than pass -them around. We'd also like to have all the IdInfo available for each -one: i.e. everything that gets pulled out of the interface file. - -The solution is to generate this map of global Ids after the -typechecker, and assign it to a global variable. Any subsequent -pass may refer to the map to pull Ids out. Any invalid -(i.e. pre-typechecker) access to the map will result in a panic. +GHC.Prim "exports" all the primops and primitive types, some +wired-in Ids. \begin{code} -thinAirIdNames - = map mkKnownKeyGlobal - [ - -- Needed for converting literals to Integers (used in tidyCoreExpr) - (varQual (pREL_BASE, SLIT("int2Integer")), int2IntegerIdKey) - , (varQual (pREL_BASE, SLIT("addr2Integer")), addr2IntegerIdKey) - - -- OK, this is Will's idea: we should have magic values for Integers 0, - -- +1, +2, and -1 (go ahead, fire me): - , (varQual (pREL_BASE, SLIT("integer_0")), integerZeroIdKey) - , (varQual (pREL_BASE, SLIT("integer_1")), integerPlusOneIdKey) - , (varQual (pREL_BASE, SLIT("integer_2")), integerPlusTwoIdKey) - , (varQual (pREL_BASE, SLIT("integer_m1")), integerMinusOneIdKey) - - - -- String literals - , (varQual (pREL_PACK, SLIT("packCString#")), packCStringIdKey) - , (varQual (pREL_PACK, SLIT("unpackCString#")), unpackCStringIdKey) - , (varQual (pREL_PACK, SLIT("unpackNBytes#")), unpackCString2IdKey) - , (varQual (pREL_PACK, SLIT("unpackAppendCString#")), unpackCStringAppendIdKey) - , (varQual (pREL_PACK, SLIT("unpackFoldrCString#")), unpackCStringFoldrIdKey) - - -- Folds; introduced by desugaring list comprehensions - , (varQual (pREL_BASE, SLIT("foldr")), foldrIdKey) - ] - -thinAirModules = [pREL_PACK] -- See notes with RnIfaces.findAndReadIface - -noRepIntegerIds = [integerZeroId, integerPlusOneId, integerPlusTwoId, integerMinusOneId, - int2IntegerId, addr2IntegerId] - -noRepStrIds = [unpackCString2Id, unpackCStringId] - -int2IntegerId = lookupThinAirId int2IntegerIdKey -addr2IntegerId = lookupThinAirId addr2IntegerIdKey - -integerMinusOneId = lookupThinAirId integerMinusOneIdKey -integerZeroId = lookupThinAirId integerZeroIdKey -integerPlusOneId = lookupThinAirId integerPlusOneIdKey -integerPlusTwoId = lookupThinAirId integerPlusTwoIdKey - -packStringForCId = lookupThinAirId packCStringIdKey -unpackCStringId = lookupThinAirId unpackCStringIdKey -unpackCString2Id = lookupThinAirId unpackCString2IdKey -unpackCStringAppendId = lookupThinAirId unpackCStringAppendIdKey -unpackCStringFoldrId = lookupThinAirId unpackCStringFoldrIdKey - -foldrId = lookupThinAirId foldrIdKey -\end{code} - - -\begin{code} -\end{code} - -\begin{code} -thinAirIdMapRef :: IORef (UniqFM Id) -thinAirIdMapRef = unsafePerformIO (newIORef (panic "thinAirIdMap: still empty")) - -setThinAirIds :: [Id] -> IO () -setThinAirIds thin_air_ids - = writeIORef thinAirIdMapRef the_map - where - the_map = listToUFM [(varUnique id, id) | id <- thin_air_ids] - -thinAirIdMap :: UniqFM Id -thinAirIdMap = unsafePerformIO (readIORef thinAirIdMapRef) - -- Read it just once, the first time someone tugs on thinAirIdMap - -lookupThinAirId :: Unique -> Id -lookupThinAirId uniq = lookupWithDefaultUFM thinAirIdMap - (panic "lookupThinAirId: no mapping") uniq +ghcPrimExports :: [RdrAvailInfo] + = map (Avail . nameOccName . idName) ghcPrimIds ++ + map (Avail . primOpOcc) allThePrimOps ++ + [ AvailTC occ [occ] | + n <- funTyCon : primTyCons, let occ = nameOccName (tyConName n) + ] \end{code} @@ -332,372 +115,26 @@ lookupThinAirId uniq = lookupWithDefaultUFM thinAirIdMap %* * %************************************************************************ -Ids, Synonyms, Classes and ClassOps with builtin keys. - -\begin{code} -mkKnownKeyGlobal :: (RdrName, Unique) -> Name -mkKnownKeyGlobal (Qual mod occ hif, uniq) - = mkGlobalName uniq mod occ NoProvenance - -ioTyCon_NAME = mkKnownKeyGlobal (ioTyCon_RDR, ioTyConKey) -main_NAME = mkKnownKeyGlobal (main_RDR, mainKey) - - -- Operations needed when compiling FFI decls -bindIO_NAME = mkKnownKeyGlobal (bindIO_RDR, bindIOIdKey) -deRefStablePtr_NAME = mkKnownKeyGlobal (deRefStablePtr_RDR, deRefStablePtrIdKey) -makeStablePtr_NAME = mkKnownKeyGlobal (makeStablePtr_RDR, makeStablePtrIdKey) - -knownKeyNames :: [Name] -knownKeyNames - = [main_NAME, ioTyCon_NAME] - ++ - map mkKnownKeyGlobal - [ - -- Type constructors (synonyms especially) - (orderingTyCon_RDR, orderingTyConKey) - , (rationalTyCon_RDR, rationalTyConKey) - , (ratioDataCon_RDR, ratioDataConKey) - , (ratioTyCon_RDR, ratioTyConKey) - , (byteArrayTyCon_RDR, byteArrayTyConKey) - , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey) - , (foreignObjTyCon_RDR, foreignObjTyConKey) - , (stablePtrTyCon_RDR, stablePtrTyConKey) - - -- Classes. *Must* include: - -- classes that are grabbed by key (e.g., eqClassKey) - -- classes in "Class.standardClassKeys" (quite a few) - , (eqClass_RDR, eqClassKey) -- mentioned, derivable - , (ordClass_RDR, ordClassKey) -- derivable - , (boundedClass_RDR, boundedClassKey) -- derivable - , (numClass_RDR, numClassKey) -- mentioned, numeric - , (enumClass_RDR, enumClassKey) -- derivable - , (monadClass_RDR, monadClassKey) - , (monadPlusClass_RDR, monadPlusClassKey) - , (functorClass_RDR, functorClassKey) - , (showClass_RDR, showClassKey) -- derivable - , (realClass_RDR, realClassKey) -- numeric - , (integralClass_RDR, integralClassKey) -- numeric - , (fractionalClass_RDR, fractionalClassKey) -- numeric - , (floatingClass_RDR, floatingClassKey) -- numeric - , (realFracClass_RDR, realFracClassKey) -- numeric - , (realFloatClass_RDR, realFloatClassKey) -- numeric - , (readClass_RDR, readClassKey) -- derivable - , (ixClass_RDR, ixClassKey) -- derivable (but it isn't Prelude.Ix; hmmm) - , (ccallableClass_RDR, cCallableClassKey) -- mentioned, ccallish - , (creturnableClass_RDR, cReturnableClassKey) -- mentioned, ccallish - - -- ClassOps - , (fromInt_RDR, fromIntClassOpKey) - , (fromInteger_RDR, fromIntegerClassOpKey) - , (ge_RDR, geClassOpKey) - , (minus_RDR, minusClassOpKey) - , (enumFrom_RDR, enumFromClassOpKey) - , (enumFromThen_RDR, enumFromThenClassOpKey) - , (enumFromTo_RDR, enumFromToClassOpKey) - , (enumFromThenTo_RDR, enumFromThenToClassOpKey) - , (fromEnum_RDR, fromEnumClassOpKey) - , (toEnum_RDR, toEnumClassOpKey) - , (eq_RDR, eqClassOpKey) - , (thenM_RDR, thenMClassOpKey) - , (returnM_RDR, returnMClassOpKey) - , (failM_RDR, failMClassOpKey) - , (fromRational_RDR, fromRationalClassOpKey) - - , (deRefStablePtr_RDR, deRefStablePtrIdKey) - , (makeStablePtr_RDR, makeStablePtrIdKey) - , (bindIO_RDR, bindIOIdKey) - - , (map_RDR, mapIdKey) - , (append_RDR, appendIdKey) - - -- List operations - , (concat_RDR, concatIdKey) - , (filter_RDR, filterIdKey) - , (zip_RDR, zipIdKey) - - -- Others - , (otherwiseId_RDR, otherwiseIdKey) - , (assert_RDR, assertIdKey) - ] -\end{code} - ToDo: make it do the ``like'' part properly (as in 0.26 and before). \begin{code} maybeCharLikeCon, maybeIntLikeCon :: DataCon -> Bool -maybeCharLikeCon con = getUnique con == charDataConKey -maybeIntLikeCon con = getUnique con == intDataConKey -\end{code} - -%************************************************************************ -%* * -\subsection{Commonly-used RdrNames} -%* * -%************************************************************************ - -These RdrNames 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} -prelude_primop op = qual (modAndOcc (mkPrimitiveId op)) - -main_RDR = varQual (mAIN, SLIT("main")) -otherwiseId_RDR = varQual (pREL_BASE, SLIT("otherwise")) - -intTyCon_RDR = qual (modAndOcc intTyCon) -ioTyCon_RDR = tcQual (pREL_IO_BASE, SLIT("IO")) -ioDataCon_RDR = varQual (pREL_IO_BASE, SLIT("IO")) -bindIO_RDR = varQual (pREL_IO_BASE, SLIT("bindIO")) - -orderingTyCon_RDR = tcQual (pREL_BASE, SLIT("Ordering")) -rationalTyCon_RDR = tcQual (pREL_NUM, SLIT("Rational")) -ratioTyCon_RDR = tcQual (pREL_NUM, SLIT("Ratio")) -ratioDataCon_RDR = varQual (pREL_NUM, SLIT(":%")) - -byteArrayTyCon_RDR = tcQual (pREL_ARR, SLIT("ByteArray")) -mutableByteArrayTyCon_RDR = tcQual (pREL_ARR, SLIT("MutableByteArray")) - -foreignObjTyCon_RDR = tcQual (pREL_IO_BASE, SLIT("ForeignObj")) -stablePtrTyCon_RDR = tcQual (pREL_FOREIGN, SLIT("StablePtr")) -deRefStablePtr_RDR = varQual (pREL_FOREIGN, SLIT("deRefStablePtr")) -makeStablePtr_RDR = varQual (pREL_FOREIGN, SLIT("makeStablePtr")) - -eqClass_RDR = tcQual (pREL_BASE, SLIT("Eq")) -ordClass_RDR = tcQual (pREL_BASE, SLIT("Ord")) -boundedClass_RDR = tcQual (pREL_BASE, SLIT("Bounded")) -numClass_RDR = tcQual (pREL_BASE, SLIT("Num")) -enumClass_RDR = tcQual (pREL_BASE, SLIT("Enum")) -monadClass_RDR = tcQual (pREL_BASE, SLIT("Monad")) -monadPlusClass_RDR = tcQual (pREL_BASE, SLIT("MonadPlus")) -functorClass_RDR = tcQual (pREL_BASE, SLIT("Functor")) -showClass_RDR = tcQual (pREL_BASE, SLIT("Show")) -realClass_RDR = tcQual (pREL_NUM, SLIT("Real")) -integralClass_RDR = tcQual (pREL_NUM, SLIT("Integral")) -fractionalClass_RDR = tcQual (pREL_NUM, SLIT("Fractional")) -floatingClass_RDR = tcQual (pREL_NUM, SLIT("Floating")) -realFracClass_RDR = tcQual (pREL_NUM, SLIT("RealFrac")) -realFloatClass_RDR = tcQual (pREL_NUM, SLIT("RealFloat")) -readClass_RDR = tcQual (pREL_READ, SLIT("Read")) -ixClass_RDR = tcQual (iX, SLIT("Ix")) -ccallableClass_RDR = tcQual (pREL_GHC, SLIT("CCallable")) -creturnableClass_RDR = tcQual (pREL_GHC, SLIT("CReturnable")) - -fromInt_RDR = varQual (pREL_BASE, SLIT("fromInt")) -fromInteger_RDR = varQual (pREL_BASE, SLIT("fromInteger")) -minus_RDR = varQual (pREL_BASE, SLIT("-")) -succ_RDR = varQual (pREL_BASE, SLIT("succ")) -pred_RDR = varQual (pREL_BASE, SLIT("pred")) -toEnum_RDR = varQual (pREL_BASE, SLIT("toEnum")) -fromEnum_RDR = varQual (pREL_BASE, SLIT("fromEnum")) -enumFrom_RDR = varQual (pREL_BASE, SLIT("enumFrom")) -enumFromTo_RDR = varQual (pREL_BASE, SLIT("enumFromTo")) -enumFromThen_RDR = varQual (pREL_BASE, SLIT("enumFromThen")) -enumFromThenTo_RDR = varQual (pREL_BASE, SLIT("enumFromThenTo")) - -thenM_RDR = varQual (pREL_BASE, SLIT(">>=")) -returnM_RDR = varQual (pREL_BASE, SLIT("return")) -failM_RDR = varQual (pREL_BASE, SLIT("fail")) - -fromRational_RDR = varQual (pREL_NUM, SLIT("fromRational")) -negate_RDR = varQual (pREL_BASE, SLIT("negate")) -eq_RDR = varQual (pREL_BASE, SLIT("==")) -ne_RDR = varQual (pREL_BASE, SLIT("/=")) -le_RDR = varQual (pREL_BASE, SLIT("<=")) -lt_RDR = varQual (pREL_BASE, SLIT("<")) -ge_RDR = varQual (pREL_BASE, SLIT(">=")) -gt_RDR = varQual (pREL_BASE, SLIT(">")) -ltTag_RDR = varQual (pREL_BASE, SLIT("LT")) -eqTag_RDR = varQual (pREL_BASE, SLIT("EQ")) -gtTag_RDR = varQual (pREL_BASE, SLIT("GT")) -max_RDR = varQual (pREL_BASE, SLIT("max")) -min_RDR = varQual (pREL_BASE, SLIT("min")) -compare_RDR = varQual (pREL_BASE, SLIT("compare")) -minBound_RDR = varQual (pREL_BASE, SLIT("minBound")) -maxBound_RDR = varQual (pREL_BASE, SLIT("maxBound")) -false_RDR = varQual (pREL_BASE, SLIT("False")) -true_RDR = varQual (pREL_BASE, SLIT("True")) -and_RDR = varQual (pREL_BASE, SLIT("&&")) -not_RDR = varQual (pREL_BASE, SLIT("not")) -compose_RDR = varQual (pREL_BASE, SLIT(".")) -append_RDR = varQual (pREL_BASE, SLIT("++")) -map_RDR = varQual (pREL_BASE, SLIT("map")) -concat_RDR = varQual (pREL_LIST, SLIT("concat")) -filter_RDR = varQual (pREL_LIST, SLIT("filter")) -zip_RDR = varQual (pREL_LIST, SLIT("zip")) - -showList___RDR = varQual (pREL_BASE, SLIT("showList__")) -showsPrec_RDR = varQual (pREL_BASE, SLIT("showsPrec")) -showList_RDR = varQual (pREL_BASE, SLIT("showList")) -showSpace_RDR = varQual (pREL_BASE, SLIT("showSpace")) -showString_RDR = varQual (pREL_BASE, SLIT("showString")) -showParen_RDR = varQual (pREL_BASE, SLIT("showParen")) - -range_RDR = varQual (iX, SLIT("range")) -index_RDR = varQual (iX, SLIT("index")) -inRange_RDR = varQual (iX, SLIT("inRange")) - -readsPrec_RDR = varQual (pREL_READ, SLIT("readsPrec")) -readList_RDR = varQual (pREL_READ, SLIT("readList")) -readParen_RDR = varQual (pREL_READ, SLIT("readParen")) -lex_RDR = varQual (pREL_READ, SLIT("lex")) -readList___RDR = varQual (pREL_READ, SLIT("readList__")) - -plus_RDR = varQual (pREL_BASE, SLIT("+")) -times_RDR = varQual (pREL_BASE, SLIT("*")) -mkInt_RDR = varQual (pREL_BASE, SLIT("I#")) - -error_RDR = varQual (pREL_ERR, SLIT("error")) -assert_RDR = varQual (pREL_GHC, SLIT("assert")) -assertErr_RDR = varQual (pREL_ERR, SLIT("assertError")) - -eqH_Char_RDR = prelude_primop CharEqOp -ltH_Char_RDR = prelude_primop CharLtOp -eqH_Word_RDR = prelude_primop WordEqOp -ltH_Word_RDR = prelude_primop WordLtOp -eqH_Addr_RDR = prelude_primop AddrEqOp -ltH_Addr_RDR = prelude_primop AddrLtOp -eqH_Float_RDR = prelude_primop FloatEqOp -ltH_Float_RDR = prelude_primop FloatLtOp -eqH_Double_RDR = prelude_primop DoubleEqOp -ltH_Double_RDR = prelude_primop DoubleLtOp -eqH_Int_RDR = prelude_primop IntEqOp -ltH_Int_RDR = prelude_primop IntLtOp -geH_RDR = prelude_primop IntGeOp -leH_RDR = prelude_primop IntLeOp -minusH_RDR = prelude_primop IntSubOp -\end{code} - -\begin{code} -mkTupConRdrName :: Int -> RdrName -mkTupConRdrName arity = varQual (mkTupNameStr arity) - -mkUbxTupConRdrName :: Int -> RdrName -mkUbxTupConRdrName arity = varQual (mkUbxTupNameStr arity) +maybeCharLikeCon con = con `hasKey` charDataConKey +maybeIntLikeCon con = con `hasKey` intDataConKey \end{code} %************************************************************************ %* * -\subsection[Class-std-groups]{Standard groups of Prelude classes} +\subsection{Class predicates} %* * %************************************************************************ -@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, 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, - 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, - 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. - \begin{code} -isCcallishClass, isCreturnableClass, isNoDictClass, - isNumericClass, isStandardClass :: Class -> Bool +isNoDictClass, isNumericClass, isStandardClass :: Class -> Bool isNumericClass clas = classKey clas `is_elem` numericClassKeys isStandardClass clas = classKey clas `is_elem` standardClassKeys -isCcallishClass clas = classKey clas `is_elem` cCallishClassKeys -isCreturnableClass clas = classKey clas == cReturnableClassKey isNoDictClass clas = classKey clas `is_elem` noDictClassKeys is_elem = isIn "is_X_Class" - -numericClassKeys = - [ numClassKey - , realClassKey - , integralClassKey - , fractionalClassKey - , floatingClassKey - , realFracClassKey - , realFloatClassKey - ] - - -- the strictness analyser needs to know about numeric types - -- (see SaAbsInt.lhs) -numericTyKeys = - [ addrTyConKey - , wordTyConKey - , intTyConKey - , integerTyConKey - , doubleTyConKey - , floatTyConKey - ] - -needsDataDeclCtxtClassKeys = -- see comments in TcDeriv - [ readClassKey - ] - -cCallishClassKeys = - [ cCallableClassKey - , cReturnableClassKey - ] - - -- Renamer always imports these data decls replete with constructors - -- so that desugarer can always see the constructor. Ugh! -cCallishTyKeys = - [ addrTyConKey - , wordTyConKey - , byteArrayTyConKey - , mutableByteArrayTyConKey - , foreignObjTyConKey - , stablePtrTyConKey - ] - -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 \end{code}