%
-% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
+% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[PrelInfo]{The @PrelInfo@ interface to the compiler's prelude knowledge}
\begin{code}
-#include "HsVersions.h"
-
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,
+
+ -- 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
- -- finite maps for built-in things (for the renamer and typechecker):
- builtinNameInfo, BuiltinNames(..),
- BuiltinKeys(..), BuiltinIdInfos(..),
-
- maybeCharLikeTyCon, maybeIntLikeTyCon
) where
-IMP_Ubiq()
-IMPORT_DELOOPER(PrelLoop) ( primOpNameInfo )
+#include "HsVersions.h"
+
-- friends:
import PrelMods -- Prelude module names
import PrelVals -- VALUES
+import MkId ( mkPrimitiveId )
import PrimOp ( PrimOp(..), allThePrimOps )
+import DataCon ( DataCon )
import PrimRep ( PrimRep(..) )
import TysPrim -- TYPES
import TysWiredIn
-- others:
-import CmdLineOpts ( opt_HideBuiltinNames,
- opt_HideMostBuiltinNames,
- opt_ForConcurrent
+import RdrName ( RdrName, mkPreludeQual )
+import Var ( varUnique, Id )
+import Name ( Name, OccName, Provenance(..),
+ NameSpace, tcName, clsName, varName, dataName,
+ getName, mkGlobalName, nameRdrName, systemProvenance
)
-import FiniteMap ( FiniteMap, emptyFM, listToFM )
-import Id ( mkTupleCon, GenId, Id(..) )
-import Maybes ( catMaybes )
-import Name ( origName, OrigName(..) )
-import RnHsSyn ( RnName(..) )
-import TyCon ( tyConDataCons, mkFunTyCon, mkTupleTyCon, TyCon )
-import Type
-import UniqFM ( UniqFM, emptyUFM, listToUFM )
+import RdrName ( rdrNameModule, rdrNameOcc, mkSrcQual )
+import Class ( Class, classKey )
+import TyCon ( tyConDataCons, TyCon )
+import Type ( funTyCon )
+import Bag
import Unique -- *Key stuff
-import Util ( nOfThem, panic )
+import UniqFM ( UniqFM, listToUFM, lookupWithDefaultUFM )
+import Util ( isIn )
+import Panic ( panic )
+
+import IOExts
\end{code}
%************************************************************************
@Classes@, the other to look up values.
\begin{code}
-builtinNameInfo :: ( BuiltinNames, BuiltinKeys, BuiltinIdInfos )
-
-type BuiltinNames = (FiniteMap OrigName RnName, -- WiredIn Ids
- FiniteMap OrigName RnName) -- WiredIn TyCons
- -- Two maps because "[]" is in both...
-
-type BuiltinKeys = FiniteMap OrigName (Unique, Name -> RnName)
- -- Names with known uniques
-
-type BuiltinIdInfos = UniqFM IdInfo -- Info for known unique Ids
-
-builtinNameInfo
- = if opt_HideBuiltinNames then
- (
- (emptyFM, emptyFM),
- emptyFM,
- emptyUFM
- )
- else if opt_HideMostBuiltinNames then
- (
- (listToFM min_assoc_val_wired, listToFM min_assoc_tc_wired),
- emptyFM,
- emptyUFM
- )
- else
- (
- (listToFM assoc_val_wired, listToFM assoc_tc_wired),
- listToFM assoc_keys,
- listToUFM assoc_id_infos
- )
+builtinNames :: Bag Name
+builtinNames
+ = unionManyBags
+ [ -- Wired in TyCons
+ unionManyBags (map getTyConNames wired_in_tycons)
- where
- min_assoc_val_wired -- min needed when compiling bits of Prelude
- = concat [
- -- data constrs
- concat (map pcDataConWiredInInfo g_con_tycons),
- concat (map pcDataConWiredInInfo min_nonprim_tycon_list),
-
- -- values
- map pcIdWiredInInfo wired_in_ids,
- primop_ids
- ]
- min_assoc_tc_wired
- = concat [
- -- tycons
- map pcTyConWiredInInfo prim_tycons,
- map pcTyConWiredInInfo g_tycons,
- map pcTyConWiredInInfo min_nonprim_tycon_list
- ]
-
- assoc_val_wired
- = concat [
- -- data constrs
- concat (map pcDataConWiredInInfo g_con_tycons),
- concat (map pcDataConWiredInInfo data_tycons),
-
- -- values
- map pcIdWiredInInfo wired_in_ids,
- primop_ids
- ]
- assoc_tc_wired
- = concat [
- -- tycons
- map pcTyConWiredInInfo prim_tycons,
- map pcTyConWiredInInfo g_tycons,
- map pcTyConWiredInInfo data_tycons
- ]
-
- assoc_keys
- = concat
- [
- id_keys,
- tysyn_keys,
- class_keys,
- class_op_keys
- ]
-
- id_keys = map id_key id_keys_infos
- id_key (str_mod, uniq, info) = (str_mod, (uniq, RnImplicit))
-
- assoc_id_infos = catMaybes (map assoc_info id_keys_infos)
- assoc_info (str_mod, uniq, Just info) = Just (uniq, info)
- assoc_info (str_mod, uniq, Nothing) = Nothing
+ -- Wired in Ids
+ , listToBag (map getName wired_in_ids)
+
+ -- 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
+\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.
-The WiredIn TyCons and DataCons ...
+
+%************************************************************************
+%* *
+\subsection{Wired in TyCons}
+%* *
+%************************************************************************
+
\begin{code}
+wired_in_tycons = [funTyCon] ++
+ prim_tycons ++
+ tuple_tycons ++
+ unboxed_tuple_tycons ++
+ data_tycons
prim_tycons
= [ addrPrimTyCon
, doublePrimTyCon
, floatPrimTyCon
, intPrimTyCon
+ , int64PrimTyCon
, foreignObjPrimTyCon
+ , weakPrimTyCon
, mutableArrayPrimTyCon
, mutableByteArrayPrimTyCon
- , synchVarPrimTyCon
+ , mVarPrimTyCon
+ , mutVarPrimTyCon
, realWorldTyCon
, stablePtrPrimTyCon
+ , stableNamePrimTyCon
, statePrimTyCon
+ , threadIdPrimTyCon
, wordPrimTyCon
+ , word64PrimTyCon
]
-g_tycons
- = mkFunTyCon : g_con_tycons
-
-g_con_tycons
- = listTyCon : mkTupleTyCon 0 : [mkTupleTyCon i | i <- [2..32] ]
-
-min_nonprim_tycon_list -- used w/ HideMostBuiltinNames
- = [ boolTyCon
- , charTyCon
- , intTyCon
- , floatTyCon
- , doubleTyCon
- , integerTyCon
- , liftTyCon
- , return2GMPsTyCon -- ADR asked for these last two (WDP 94/11)
- , returnIntAndGMPTyCon
- ]
-
+tuple_tycons = unitTyCon : [tupleTyCon i | i <- [2..37] ]
+unboxed_tuple_tycons = [unboxedTupleTyCon i | i <- [1..37] ]
data_tycons
= [ addrTyCon
, charTyCon
, doubleTyCon
, floatTyCon
- , foreignObjTyCon
, intTyCon
+ , int8TyCon
+ , int16TyCon
+ , int32TyCon
+ , int64TyCon
, integerTyCon
- , liftTyCon
- , primIoTyCon
- , return2GMPsTyCon
- , returnIntAndGMPTyCon
- , stTyCon
- , stablePtrTyCon
- , stateAndAddrPrimTyCon
- , stateAndArrayPrimTyCon
- , stateAndByteArrayPrimTyCon
- , stateAndCharPrimTyCon
- , stateAndDoublePrimTyCon
- , stateAndFloatPrimTyCon
- , stateAndForeignObjPrimTyCon
- , stateAndIntPrimTyCon
- , stateAndMutableArrayPrimTyCon
- , stateAndMutableByteArrayPrimTyCon
- , stateAndPtrPrimTyCon
- , stateAndStablePtrPrimTyCon
- , stateAndSynchVarPrimTyCon
- , stateAndWordPrimTyCon
- , stateTyCon
- , voidTyCon
+ , listTyCon
, wordTyCon
+ , word8TyCon
+ , word16TyCon
+ , word32TyCon
+ , word64TyCon
]
\end{code}
-The WiredIn Ids ...
-ToDo: Some of these should be moved to id_keys_infos!
+
+%************************************************************************
+%* *
+\subsection{Wired in Ids}
+%* *
+%************************************************************************
+
\begin{code}
wired_in_ids
- = [ aBSENT_ERROR_ID
- , augmentId
- , buildId
- , copyableId
+ = [ -- 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
- , foldlId
- , foldrId
- , forkId
, iRREFUT_PAT_ERROR_ID
- , integerMinusOneId
- , integerPlusOneId
- , integerPlusTwoId
- , integerZeroId
, nON_EXHAUSTIVE_GUARDS_ERROR_ID
- , nO_DEFAULT_METHOD_ERROR_ID
- , nO_EXPLICIT_METHOD_ERROR_ID
- , noFollowId
+ , nO_METHOD_BINDING_ERROR_ID
, pAR_ERROR_ID
, pAT_ERROR_ID
- , packStringForCId
- , parAtAbsId
- , parAtForNowId
- , parAtId
- , parAtRelId
- , parGlobalId
- , parId
- , parLocalId
, rEC_CON_ERROR_ID
, rEC_UPD_ERROR_ID
+
+ -- These two can't be defined in Haskell
, realWorldPrimId
- , runSTId
- , seqId
- , tRACE_ID
- , tRACE_ID
- , unpackCString2Id
- , unpackCStringAppendId
- , unpackCStringFoldrId
- , unpackCStringId
- , voidId
+ , unsafeCoerceId
+ ]
+
+\end{code}
+
+%************************************************************************
+%* *
+\subsection{Thin air entities}
+%* *
+%************************************************************************
+
+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.
+
+\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)
]
-pcTyConWiredInInfo :: TyCon -> (OrigName, RnName)
-pcTyConWiredInInfo tc = (origName "pcTyConWiredInInfo" tc, WiredInTyCon tc)
+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}
-pcDataConWiredInInfo :: TyCon -> [(OrigName, RnName)]
-pcDataConWiredInInfo tycon
- = [ (origName "pcDataConWiredInInfo" con, WiredInId con) | con <- tyConDataCons tycon ]
-pcIdWiredInInfo :: Id -> (OrigName, RnName)
-pcIdWiredInInfo id = (origName "pcIdWiredInInfo" id, WiredInId id)
+\begin{code}
\end{code}
-WiredIn primitive numeric operations ...
\begin{code}
-primop_ids
- = map prim_fn allThePrimOps ++ map funny_fn funny_name_primops
+thinAirIdMapRef :: IORef (UniqFM Id)
+thinAirIdMapRef = unsafePerformIO (newIORef (panic "thinAirIdMap: still empty"))
+
+setThinAirIds :: [Id] -> IO ()
+setThinAirIds thin_air_ids
+ = writeIORef thinAirIdMapRef the_map
where
- prim_fn op = case (primOpNameInfo op) of (s,n) -> ((OrigName gHC_BUILTINS s),n)
- funny_fn (op,s) = case (primOpNameInfo op) of (_,n) -> ((OrigName gHC_BUILTINS s),n)
-
-funny_name_primops
- = [ (IntAddOp, SLIT("+#"))
- , (IntSubOp, SLIT("-#"))
- , (IntMulOp, SLIT("*#"))
- , (IntGtOp, SLIT(">#"))
- , (IntGeOp, SLIT(">=#"))
- , (IntEqOp, SLIT("==#"))
- , (IntNeOp, SLIT("/=#"))
- , (IntLtOp, SLIT("<#"))
- , (IntLeOp, SLIT("<=#"))
- , (DoubleAddOp, SLIT("+##"))
- , (DoubleSubOp, SLIT("-##"))
- , (DoubleMulOp, SLIT("*##"))
- , (DoubleDivOp, SLIT("/##"))
- , (DoublePowerOp, SLIT("**##"))
- , (DoubleGtOp, SLIT(">##"))
- , (DoubleGeOp, SLIT(">=##"))
- , (DoubleEqOp, SLIT("==##"))
- , (DoubleNeOp, SLIT("/=##"))
- , (DoubleLtOp, SLIT("<##"))
- , (DoubleLeOp, SLIT("<=##"))
- ]
+ 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
\end{code}
-Ids, Synonyms, Classes and ClassOps with builtin keys.
-For the Ids we may also have some builtin IdInfo.
+%************************************************************************
+%* *
+\subsection{Built-in keys}
+%* *
+%************************************************************************
+
+Ids, Synonyms, Classes and ClassOps with builtin keys.
+
\begin{code}
-id_keys_infos :: [(OrigName, Unique, Maybe IdInfo)]
-id_keys_infos
- = [ -- here so we can check the type of main/mainPrimIO
- (OrigName SLIT("Main") SLIT("main"), mainIdKey, Nothing)
- , (OrigName SLIT("Main") SLIT("mainPrimIO"), mainPrimIOIdKey, Nothing)
-
- -- here because we use them in derived instances
- , (OrigName pRELUDE SLIT("&&"), andandIdKey, Nothing)
- , (OrigName pRELUDE SLIT("."), composeIdKey, Nothing)
- , (OrigName pRELUDE SLIT("lex"), lexIdKey, Nothing)
- , (OrigName pRELUDE SLIT("not"), notIdKey, Nothing)
- , (OrigName pRELUDE SLIT("readParen"), readParenIdKey, Nothing)
- , (OrigName pRELUDE SLIT("showParen"), showParenIdKey, Nothing)
- , (OrigName pRELUDE SLIT("showString"), showStringIdKey,Nothing)
- , (OrigName gHC__ SLIT("readList__"), ureadListIdKey, Nothing)
- , (OrigName gHC__ SLIT("showList__"), ushowListIdKey, Nothing)
- , (OrigName gHC__ SLIT("showSpace"), showSpaceIdKey, Nothing)
+mkKnownKeyGlobal :: (RdrName, Unique) -> Name
+mkKnownKeyGlobal (rdr_name, uniq)
+ = mkGlobalName uniq (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
+ systemProvenance
+
+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 = nameRdrName (getName (mkPrimitiveId op))
+
+main_RDR = varQual mAIN SLIT("main")
+otherwiseId_RDR = varQual pREL_BASE SLIT("otherwise")
+
+intTyCon_RDR = nameRdrName (getName intTyCon)
+ioTyCon_RDR = tcQual pREL_IO_BASE SLIT("IO")
+ioDataCon_RDR = dataQual 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 = dataQual 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_STABLE SLIT("StablePtr")
+deRefStablePtr_RDR = varQual pREL_STABLE SLIT("deRefStablePtr")
+makeStablePtr_RDR = varQual pREL_STABLE SLIT("makeStablePtr")
+
+eqClass_RDR = clsQual pREL_BASE SLIT("Eq")
+ordClass_RDR = clsQual pREL_BASE SLIT("Ord")
+boundedClass_RDR = clsQual pREL_BASE SLIT("Bounded")
+numClass_RDR = clsQual pREL_BASE SLIT("Num")
+enumClass_RDR = clsQual pREL_BASE SLIT("Enum")
+monadClass_RDR = clsQual pREL_BASE SLIT("Monad")
+monadPlusClass_RDR = clsQual pREL_BASE SLIT("MonadPlus")
+functorClass_RDR = clsQual pREL_BASE SLIT("Functor")
+showClass_RDR = clsQual pREL_BASE SLIT("Show")
+realClass_RDR = clsQual pREL_NUM SLIT("Real")
+integralClass_RDR = clsQual pREL_NUM SLIT("Integral")
+fractionalClass_RDR = clsQual pREL_NUM SLIT("Fractional")
+floatingClass_RDR = clsQual pREL_NUM SLIT("Floating")
+realFracClass_RDR = clsQual pREL_NUM SLIT("RealFrac")
+realFloatClass_RDR = clsQual pREL_NUM SLIT("RealFloat")
+readClass_RDR = clsQual pREL_READ SLIT("Read")
+ixClass_RDR = clsQual iX SLIT("Ix")
+ccallableClass_RDR = clsQual pREL_GHC SLIT("CCallable")
+creturnableClass_RDR = clsQual 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 = dataQual pREL_BASE SLIT("LT")
+eqTag_RDR = dataQual pREL_BASE SLIT("EQ")
+gtTag_RDR = dataQual 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 = dataQual pREL_BASE SLIT("False")
+true_RDR = dataQual 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 mONAD SLIT("concat")
+filter_RDR = varQual mONAD 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 = dataQual 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}
-tysyn_keys
- = [ (OrigName gHC__ SLIT("IO"), (iOTyConKey, RnImplicitTyCon))
- , (OrigName pRELUDE SLIT("Ordering"), (orderingTyConKey, RnImplicitTyCon))
- , (OrigName rATIO SLIT("Rational"), (rationalTyConKey, RnImplicitTyCon))
- , (OrigName rATIO SLIT("Ratio"), (ratioTyConKey, RnImplicitTyCon))
+\begin{code}
+mkTupConRdrName :: Int -> RdrName
+mkTupConRdrName arity = case mkTupNameStr arity of
+ (mod, occ) -> dataQual mod occ
+
+mkUbxTupConRdrName :: Int -> RdrName
+mkUbxTupConRdrName arity = case mkUbxTupNameStr arity of
+ (mod, occ) -> dataQual mod occ
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection[Class-std-groups]{Standard groups of Prelude classes}
+%* *
+%************************************************************************
+
+@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.
--- this "class_keys" list *must* include:
--- classes that are grabbed by key (e.g., eqClassKey)
--- classes in "Class.standardClassKeys" (quite a few)
-
-class_keys
- = [ (str_mod, (k, RnImplicitClass)) | (str_mod,k) <-
- [ (OrigName pRELUDE SLIT("Eq"), eqClassKey) -- mentioned, derivable
- , (OrigName pRELUDE SLIT("Eval"), evalClassKey) -- mentioned
- , (OrigName pRELUDE SLIT("Ord"), ordClassKey) -- derivable
- , (OrigName pRELUDE SLIT("Num"), numClassKey) -- mentioned, numeric
- , (OrigName pRELUDE SLIT("Real"), realClassKey) -- numeric
- , (OrigName pRELUDE SLIT("Integral"), integralClassKey) -- numeric
- , (OrigName pRELUDE SLIT("Fractional"), fractionalClassKey) -- numeric
- , (OrigName pRELUDE SLIT("Floating"), floatingClassKey) -- numeric
- , (OrigName pRELUDE SLIT("RealFrac"), realFracClassKey) -- numeric
- , (OrigName pRELUDE SLIT("RealFloat"), realFloatClassKey) -- numeric
- , (OrigName iX SLIT("Ix"), ixClassKey) -- derivable (but it isn't Prelude.Ix; hmmm)
- , (OrigName pRELUDE SLIT("Bounded"), boundedClassKey) -- derivable
- , (OrigName pRELUDE SLIT("Enum"), enumClassKey) -- derivable
- , (OrigName pRELUDE SLIT("Show"), showClassKey) -- derivable
- , (OrigName pRELUDE SLIT("Read"), readClassKey) -- derivable
- , (OrigName pRELUDE SLIT("Monad"), monadClassKey)
- , (OrigName pRELUDE SLIT("MonadZero"), monadZeroClassKey)
- , (OrigName pRELUDE SLIT("MonadPlus"), monadPlusClassKey)
- , (OrigName pRELUDE SLIT("Functor"), functorClassKey)
- , (OrigName gHC__ SLIT("CCallable"), cCallableClassKey) -- mentioned, ccallish
- , (OrigName gHC__ SLIT("CReturnable"), cReturnableClassKey) -- mentioned, ccallish
- ]]
-
-class_op_keys
- = [ (str_mod, (k, RnImplicit)) | (str_mod,k) <-
- [ (OrigName pRELUDE SLIT("fromInt"), fromIntClassOpKey)
- , (OrigName pRELUDE SLIT("fromInteger"), fromIntegerClassOpKey)
- , (OrigName pRELUDE SLIT("fromRational"), fromRationalClassOpKey)
- , (OrigName pRELUDE SLIT("enumFrom"), enumFromClassOpKey)
- , (OrigName pRELUDE SLIT("enumFromThen"), enumFromThenClassOpKey)
- , (OrigName pRELUDE SLIT("enumFromTo"), enumFromToClassOpKey)
- , (OrigName pRELUDE SLIT("enumFromThenTo"),enumFromThenToClassOpKey)
- , (OrigName pRELUDE SLIT("=="), eqClassOpKey)
- , (OrigName pRELUDE SLIT(">>="), thenMClassOpKey)
- , (OrigName pRELUDE SLIT("zero"), zeroClassOpKey)
- ]]
+\begin{code}
+isCcallishClass, isCreturnableClass, 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}
-ToDo: make it do the ``like'' part properly (as in 0.26 and before).
+
+%************************************************************************
+%* *
+\subsection{Local helpers}
+%* *
+%************************************************************************
+
\begin{code}
-maybeCharLikeTyCon tc = if (uniqueOf tc == charDataConKey) then Just charDataCon else Nothing
-maybeIntLikeTyCon tc = if (uniqueOf tc == intDataConKey) then Just intDataCon else Nothing
+varQual = mkPreludeQual varName
+dataQual = mkPreludeQual dataName
+tcQual = mkPreludeQual tcName
+clsQual = mkPreludeQual clsName
\end{code}
+