[project @ 1998-12-02 13:17:09 by simonm]
[ghc-hetmet.git] / ghc / compiler / prelude / PrelInfo.lhs
index f659a9b..0d16747 100644 (file)
@@ -1,45 +1,97 @@
 %
-% (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, 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,
+       monadZeroClass_RDR, enumClass_RDR, ordClass_RDR,
+       ioDataCon_RDR
 
-       -- finite maps for built-in things (for the renamer and typechecker):
-       builtinNameInfo, builtinNameMaps,
-       builtinValNamesMap, builtinTcNamesMap,
-       builtinKeysMap,
-       SYN_IE(BuiltinNames),
-       SYN_IE(BuiltinKeys), SYN_IE(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 FiniteMap       ( FiniteMap, emptyFM, listToFM )
-import Id              ( mkTupleCon, GenId, SYN_IE(Id) )
-import Maybes          ( catMaybes )
-import Name            ( origName, OrigName(..), Name )
-import RnHsSyn         ( RnName(..) )
-import TyCon           ( tyConDataCons, mkFunTyCon, mkTupleTyCon, TyCon )
-import Type
-import UniqFM          ( UniqFM, emptyUFM, listToUFM )
+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 Type            ( funTyCon )
+import Bag
 import Unique          -- *Key stuff
-import Util            ( nOfThem, panic )
+import UniqFM          ( UniqFM, listToUFM, lookupWithDefaultUFM ) 
+import Util            ( isIn, panic )
+
+import IOExts
 \end{code}
 
 %************************************************************************
@@ -52,70 +104,52 @@ We have two ``builtin name funs,'' one to look up @TyCons@ and
 @Classes@, the other to look up values.
 
 \begin{code}
-builtinNameInfo :: ( BuiltinNames, BuiltinKeys, BuiltinIdInfos )
+builtinNames :: Bag Name
+builtinNames
+  = unionManyBags
+       [       -- Wired in TyCons
+         unionManyBags (map getTyConNames wired_in_tycons)
 
-type BuiltinNames   = (FiniteMap OrigName RnName, -- WiredIn Ids
-                      FiniteMap OrigName RnName) -- WiredIn TyCons
-                       -- Two maps because "[]" is in both...
+               -- Wired in Ids
+       , listToBag (map getName wired_in_ids)
 
-type BuiltinKeys    = FiniteMap OrigName (Unique, Name -> RnName)
-                                                    -- Names with known uniques
+               -- PrimOps
+       , listToBag (map (getName . mkPrimitiveId) allThePrimOps)
 
-type BuiltinIdInfos = UniqFM IdInfo                 -- Info for known unique Ids
+               -- Thin-air ids
+       , listToBag thinAirIdNames
 
-builtinNameMaps    = case builtinNameInfo of { (x,_,_) -> x }
-builtinKeysMap    = case builtinNameInfo of { (_,x,_) -> x }
-builtinValNamesMap = fst builtinNameMaps
-builtinTcNamesMap  = snd builtinNameMaps
-
-builtinNameInfo
-  = ( (listToFM assoc_val_wired, listToFM assoc_tc_wired)
-    , listToFM assoc_keys
-    , listToUFM assoc_id_infos
-    )
-  where
-    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
+               -- 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
@@ -125,21 +159,23 @@ prim_tycons
     , doublePrimTyCon
     , floatPrimTyCon
     , intPrimTyCon
+    , int64PrimTyCon
     , foreignObjPrimTyCon
+    , weakPrimTyCon
     , mutableArrayPrimTyCon
     , mutableByteArrayPrimTyCon
-    , synchVarPrimTyCon
+    , mVarPrimTyCon
+    , mutVarPrimTyCon
     , realWorldTyCon
     , stablePtrPrimTyCon
     , statePrimTyCon
+    , threadIdPrimTyCon
     , wordPrimTyCon
+    , word64PrimTyCon
     ]
 
-g_tycons
-  = mkFunTyCon : g_con_tycons
-
-g_con_tycons
-  = listTyCon : mkTupleTyCon 0 : [mkTupleTyCon i | i <- [2..37] ]
+tuple_tycons = unitTyCon : [tupleTyCon i | i <- [2..37] ]
+unboxed_tuple_tycons = [unboxedTupleTyCon i | i <- [1..37] ]
 
 data_tycons
   = [ addrTyCon
@@ -147,194 +183,500 @@ data_tycons
     , 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
+    , listTyCon
     , voidTyCon
     , 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 inteface file that the result type variable
+       -- is 'open'; that is can be unified with an unboxed type
+      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
-    , unpackCString2Id
-    , unpackCStringAppendId
-    , unpackCStringFoldrId
-    , unpackCStringId
-    , voidId
+    , unsafeCoerceId
     ]
 
-pcTyConWiredInInfo :: TyCon -> (OrigName, RnName)
-pcTyConWiredInInfo tc = (origName "pcTyConWiredInInfo" tc, WiredInTyCon tc)
+\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.
 
-pcDataConWiredInInfo :: TyCon -> [(OrigName, RnName)]
-pcDataConWiredInInfo tycon
-  = [ (origName "pcDataConWiredInInfo" con, WiredInId con) | con <- tyConDataCons tycon ]
+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.
 
-pcIdWiredInInfo :: Id -> (OrigName, RnName)
-pcIdWiredInInfo id = (origName "pcIdWiredInInfo" id, WiredInId id)
+\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}
 
-WiredIn primitive numeric operations ...
+
 \begin{code}
-primop_ids
-  = map prim_fn allThePrimOps ++ map funny_fn funny_name_primops
+\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
-    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 because we use them in derived instances
-      (OrigName pRELUDE SLIT("&&"),            andandIdKey,    Nothing)
-    , (OrigName pRELUDE SLIT("."),             composeIdKey,   Nothing)
-    , (OrigName gHC__   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 (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)
+    , (monadZeroClass_RDR,     monadZeroClassKey)
+    , (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)
+    , (zeroM_RDR,              zeroClassOpKey)
+    , (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}
 
-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))
-    ]
+ToDo: make it do the ``like'' part properly (as in 0.26 and before).
 
--- 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}
+maybeCharLikeCon, maybeIntLikeCon :: DataCon -> Bool
+maybeCharLikeCon con = getUnique con == charDataConKey
+maybeIntLikeCon  con = getUnique con == intDataConKey
 \end{code}
 
-ToDo: make it do the ``like'' part properly (as in 0.26 and before).
+%************************************************************************
+%*                                                                     *
+\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"))
+monadZeroClass_RDR     = tcQual (pREL_BASE, SLIT("MonadZero"))
+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("-"))
+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"))
+zeroM_RDR         = varQual (pREL_BASE,    SLIT("zero"))
+
+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 (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         = 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}
+
+%************************************************************************
+%*                                                                     *
+\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, map_RDR])
+    , (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])
+    , (ixClassKey,     [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR, 
+                        returnM_RDR, zeroM_RDR])
+                            -- the last two are needed to force returnM, thenM and zeroM
+                            -- 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}
-maybeCharLikeTyCon tc = if (uniqueOf tc == charDataConKey) then Just charDataCon else Nothing
-maybeIntLikeTyCon  tc = if (uniqueOf tc == intDataConKey)  then Just intDataCon  else Nothing
+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}