ghc/compiler/prelude/PrelNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelNames]{Definitions of prelude modules}
   5
   6 The strings identify built-in prelude modules.  They are
   7 defined here so as to avod
   8
   9 [oh dear, looks like the recursive module monster caught up with
  10  and gobbled whoever was writing the above :-) -- SOF ]
  11
  12 \begin{code}
  13 module PrelNames (
  14         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  15
  16         -----------------------------------------------------------
  17         module PrelNames,       -- A huge bunch of (a) RdrNames, e.g. intTyCon_RDR
  18                                 --                 (b) Uniques   e.g. intTyConKey
  19                                 -- So many that we export them all
  20
  21         -----------------------------------------------------------
  22         knownKeyNames,
  23         mkTupNameStr, mkTupConRdrName,
  24
  25         ------------------------------------------------------------
  26         -- Goups of classes and types
  27         needsDataDeclCtxtClassKeys, cCallishClassKeys, noDictClassKeys,
  28         fractionalClassKeys, numericClassKeys, standardClassKeys,
  29         derivingOccurrences,    -- For a given class C, this tells what other
  30         derivableClassKeys,     -- things are needed as a result of a
  31                                 -- deriving(C) clause
  32         numericTyKeys, cCallishTyKeys,
  33
  34         mkUnboundName, isUnboundName
  35     ) where
  36
  37 #include "HsVersions.h"
  38
  39 import Module     ( ModuleName, mkPrelModule, mkModuleName )
  40 import OccName    ( NameSpace, UserFS, varName, dataName, tcName, clsName, mkKindOccFS )
  41 import RdrName    ( RdrName, mkOrig, mkRdrOrig, mkUnqual )
  42 import UniqFM
  43 import Unique     ( Unique, Uniquable(..), hasKey,
  44                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  45                     mkPreludeTyConUnique, mkPreludeClassUnique
  46                   )
  47 import BasicTypes ( Boxity(..), Arity )
  48 import UniqFM     ( UniqFM, listToUFM )
  49 import Name       ( Name, mkLocalName, mkKnownKeyGlobal, nameRdrName )
  50 import RdrName    ( rdrNameOcc )
  51 import SrcLoc     ( noSrcLoc )
  52 import Util       ( nOfThem )
  53 import Panic      ( panic )
  54 \end{code}
  55
  56
  57 %************************************************************************
  58 %*                                                                      *
  59 \subsection{Known key Names}
  60 %*                                                                      *
  61 %************************************************************************
  62
  63 This section tells what the compiler knows about the assocation of
  64 names with uniques.  These ones are the *non* wired-in ones.  The
  65 wired in ones are defined in TysWiredIn etc.
  66
  67 \begin{code}
  68 knownKeyNames :: [Name]
  69 knownKeyNames
  70  =  [
  71         -- Type constructors (synonyms especially)
  72         ioTyConName,
  73         mainName,
  74         orderingTyConName,
  75         rationalTyConName,
  76         ratioDataConName,
  77         ratioTyConName,
  78         byteArrayTyConName,
  79         mutableByteArrayTyConName,
  80         foreignObjTyConName,
  81         bcoPrimTyConName,
  82         stablePtrTyConName,
  83         stablePtrDataConName,
  84
  85         --  Classes.  *Must* include:
  86         --      classes that are grabbed by key (e.g., eqClassKey)
  87         --      classes in "Class.standardClassKeys" (quite a few)
  88         eqClassName,                    -- mentioned, derivable
  89         ordClassName,                   -- derivable
  90         boundedClassName,               -- derivable
  91         numClassName,                   -- mentioned, numeric
  92         enumClassName,                  -- derivable
  93         monadClassName,
  94         monadPlusClassName,
  95         functorClassName,
  96         showClassName,                  -- derivable
  97         realClassName,                  -- numeric
  98         integralClassName,              -- numeric
  99         fractionalClassName,            -- numeric
 100         floatingClassName,              -- numeric
 101         realFracClassName,              -- numeric
 102         realFloatClassName,             -- numeric
 103         readClassName,                  -- derivable
 104         ixClassName,                    -- derivable (but it isn't Prelude.Ix; hmmm)
 105         cCallableClassName,             -- mentioned, ccallish
 106         cReturnableClassName,           -- mentioned, ccallish
 107
 108         -- ClassOps
 109         fromIntName,
 110         fromIntegerName,
 111         geName,
 112         minusName,
 113         enumFromName,
 114         enumFromThenName,
 115         enumFromToName,
 116         enumFromThenToName,
 117         fromEnumName,
 118         toEnumName,
 119         eqName,
 120         thenMName,
 121         returnMName,
 122         failMName,
 123         fromRationalName,
 124
 125         deRefStablePtrName,
 126         newStablePtrName,
 127         bindIOName,
 128         returnIOName,
 129
 130         -- Strings and lists
 131         mapName,
 132         appendName,
 133         unpackCStringName,
 134         unpackCStringAppendName,
 135         unpackCStringFoldrName,
 136         unpackCStringUtf8Name,
 137
 138         -- List operations
 139         concatName,
 140         filterName,
 141         zipName,
 142         foldrName,
 143         buildName,
 144         augmentName,
 145
 146         -- FFI primitive types that are not wired-in.
 147         int8TyConName,
 148         int16TyConName,
 149         int32TyConName,
 150         int64TyConName,
 151         word8TyConName,
 152         word16TyConName,
 153         word32TyConName,
 154         word64TyConName,
 155
 156         -- Others
 157         otherwiseIdName,
 158         plusIntegerName,
 159         timesIntegerName,
 160         eqStringName,
 161         assertName,
 162         runSTRepName
 163     ]
 164 \end{code}
 165
 166
 167 %************************************************************************
 168 %*                                                                      *
 169 \subsection{Module names}
 170 %*                                                                      *
 171 %************************************************************************
 172
 173 \begin{code}
 174 pRELUDE_Name      = mkModuleName "Prelude"
 175 pREL_GHC_Name     = mkModuleName "PrelGHC"         -- Primitive types and values
 176 pREL_BASE_Name    = mkModuleName "PrelBase"
 177 pREL_ENUM_Name    = mkModuleName "PrelEnum"
 178 pREL_SHOW_Name    = mkModuleName "PrelShow"
 179 pREL_READ_Name    = mkModuleName "PrelRead"
 180 pREL_NUM_Name     = mkModuleName "PrelNum"
 181 pREL_LIST_Name    = mkModuleName "PrelList"
 182 pREL_TUP_Name     = mkModuleName "PrelTup"
 183 pREL_PACK_Name    = mkModuleName "PrelPack"
 184 pREL_CONC_Name    = mkModuleName "PrelConc"
 185 pREL_IO_BASE_Name = mkModuleName "PrelIOBase"
 186 pREL_ST_Name      = mkModuleName "PrelST"
 187 pREL_ARR_Name     = mkModuleName "PrelArr"
 188 pREL_BYTEARR_Name = mkModuleName "PrelByteArr"
 189 pREL_FOREIGN_Name = mkModuleName "PrelForeign"
 190 pREL_STABLE_Name  = mkModuleName "PrelStable"
 191 pREL_ADDR_Name    = mkModuleName "PrelAddr"
 192 pREL_ERR_Name     = mkModuleName "PrelErr"
 193 pREL_REAL_Name    = mkModuleName "PrelReal"
 194 pREL_FLOAT_Name   = mkModuleName "PrelFloat"
 195
 196 pREL_MAIN_Name    = mkModuleName "PrelMain"
 197 mAIN_Name         = mkModuleName "Main"
 198 iNT_Name          = mkModuleName "Int"
 199 wORD_Name         = mkModuleName "Word"
 200
 201 pREL_GHC        = mkPrelModule pREL_GHC_Name
 202 pREL_BASE       = mkPrelModule pREL_BASE_Name
 203 pREL_ADDR       = mkPrelModule pREL_ADDR_Name
 204 pREL_STABLE     = mkPrelModule pREL_STABLE_Name
 205 pREL_IO_BASE    = mkPrelModule pREL_IO_BASE_Name
 206 pREL_PACK       = mkPrelModule pREL_PACK_Name
 207 pREL_ERR        = mkPrelModule pREL_ERR_Name
 208 pREL_NUM        = mkPrelModule pREL_NUM_Name
 209 pREL_REAL       = mkPrelModule pREL_REAL_Name
 210 pREL_FLOAT      = mkPrelModule pREL_FLOAT_Name
 211 \end{code}
 212
 213 %************************************************************************
 214 %*                                                                      *
 215 \subsection{Constructing the names of tuples
 216 %*                                                                      *
 217 %************************************************************************
 218
 219 \begin{code}
 220 mkTupNameStr :: Boxity -> Int -> (ModuleName, UserFS)
 221
 222 mkTupNameStr Boxed 0 = (pREL_BASE_Name, SLIT("()"))
 223 mkTupNameStr Boxed 1 = panic "Name.mkTupNameStr: 1 ???"
 224 mkTupNameStr Boxed 2 = (pREL_TUP_Name, _PK_ "(,)")   -- not strictly necessary
 225 mkTupNameStr Boxed 3 = (pREL_TUP_Name, _PK_ "(,,)")  -- ditto
 226 mkTupNameStr Boxed 4 = (pREL_TUP_Name, _PK_ "(,,,)") -- ditto
 227 mkTupNameStr Boxed n = (pREL_TUP_Name, _PK_ ("(" ++ nOfThem (n-1) ',' ++ ")"))
 228
 229 mkTupNameStr Unboxed 0 = panic "Name.mkUbxTupNameStr: 0 ???"
 230 mkTupNameStr Unboxed 1 = (pREL_GHC_Name, _PK_ "(# #)") -- 1 and 0 both make sense!!!
 231 mkTupNameStr Unboxed 2 = (pREL_GHC_Name, _PK_ "(#,#)")
 232 mkTupNameStr Unboxed 3 = (pREL_GHC_Name, _PK_ "(#,,#)")
 233 mkTupNameStr Unboxed 4 = (pREL_GHC_Name, _PK_ "(#,,,#)")
 234 mkTupNameStr Unboxed n = (pREL_GHC_Name, _PK_ ("(#" ++ nOfThem (n-1) ',' ++ "#)"))
 235
 236 mkTupConRdrName :: NameSpace -> Boxity -> Arity -> RdrName
 237 mkTupConRdrName space boxity arity   = case mkTupNameStr boxity arity of
 238                                           (mod, occ) -> mkOrig space mod occ
 239 \end{code}
 240
 241
 242 %************************************************************************
 243 %*                                                                      *
 244 \subsection{Unqualified RdrNames}
 245 %*                                                                      *
 246 %************************************************************************
 247
 248 \begin{code}
 249 main_RDR_Unqual :: RdrName
 250 main_RDR_Unqual = mkUnqual varName SLIT("main")
 251 -- Don't get a RdrName from PrelNames.mainName, because nameRdrName
 252 -- gets an Orig RdrName, and we want a Qual or Unqual one.  An Unqual
 253 -- one will do fine.
 254 \end{code}
 255
 256
 257 %************************************************************************
 258 %*                                                                      *
 259 \subsection{Commonly-used RdrNames}
 260 %*                                                                      *
 261 %************************************************************************
 262
 263 Many of these Names are not really "built in", but some parts of the
 264 compiler (notably the deriving mechanism) need to mention their names,
 265 and it's convenient to write them all down in one place.
 266
 267 \begin{code}
 268 mainName = varQual mAIN_Name SLIT("main") mainKey
 269
 270 -- Stuff from PrelGHC
 271 usOnceTyConName  = kindQual SLIT(".") usOnceTyConKey
 272 usManyTyConName  = kindQual SLIT("!") usManyTyConKey
 273 superKindName    = kindQual SLIT("KX") kindConKey
 274 superBoxityName  = kindQual SLIT("BX") boxityConKey
 275 boxedConName     = kindQual SLIT("*") boxedConKey
 276 unboxedConName   = kindQual SLIT("#") unboxedConKey
 277 openKindConName  = kindQual SLIT("?") anyBoxConKey
 278 usageKindConName = kindQual SLIT("$") usageConKey
 279 typeConName      = kindQual SLIT("Type") typeConKey
 280
 281 funTyConName                  = tcQual  pREL_GHC_Name SLIT("(->)")  funTyConKey
 282 charPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Char#") charPrimTyConKey
 283 intPrimTyConName              = tcQual  pREL_GHC_Name SLIT("Int#") intPrimTyConKey
 284 int64PrimTyConName            = tcQual  pREL_GHC_Name SLIT("Int64#") int64PrimTyConKey
 285 wordPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Word#") wordPrimTyConKey
 286 word64PrimTyConName           = tcQual  pREL_GHC_Name SLIT("Word64#") word64PrimTyConKey
 287 addrPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Addr#") addrPrimTyConKey
 288 floatPrimTyConName            = tcQual  pREL_GHC_Name SLIT("Float#") floatPrimTyConKey
 289 doublePrimTyConName           = tcQual  pREL_GHC_Name SLIT("Double#") doublePrimTyConKey
 290 statePrimTyConName            = tcQual  pREL_GHC_Name SLIT("State#") statePrimTyConKey
 291 realWorldTyConName            = tcQual  pREL_GHC_Name SLIT("RealWorld") realWorldTyConKey
 292 arrayPrimTyConName            = tcQual  pREL_GHC_Name SLIT("Array#") arrayPrimTyConKey
 293 byteArrayPrimTyConName        = tcQual  pREL_GHC_Name SLIT("ByteArray#") byteArrayPrimTyConKey
 294 mutableArrayPrimTyConName     = tcQual  pREL_GHC_Name SLIT("MutableArray#") mutableArrayPrimTyConKey
 295 mutableByteArrayPrimTyConName = tcQual  pREL_GHC_Name SLIT("MutableByteArray#") mutableByteArrayPrimTyConKey
 296 mutVarPrimTyConName           = tcQual  pREL_GHC_Name SLIT("MutVar#") mutVarPrimTyConKey
 297 mVarPrimTyConName             = tcQual  pREL_GHC_Name SLIT("MVar#") mVarPrimTyConKey
 298 stablePtrPrimTyConName        = tcQual  pREL_GHC_Name SLIT("StablePtr#") stablePtrPrimTyConKey
 299 stableNamePrimTyConName       = tcQual  pREL_GHC_Name SLIT("StableName#") stableNamePrimTyConKey
 300 foreignObjPrimTyConName       = tcQual  pREL_GHC_Name SLIT("ForeignObj#") foreignObjPrimTyConKey
 301 bcoPrimTyConName              = tcQual  pREL_GHC_Name SLIT("BCO#") bcoPrimTyConKey
 302 weakPrimTyConName             = tcQual  pREL_GHC_Name SLIT("Weak#") weakPrimTyConKey
 303 threadIdPrimTyConName         = tcQual  pREL_GHC_Name SLIT("ThreadId#") threadIdPrimTyConKey
 304 cCallableClassName            = clsQual pREL_GHC_Name SLIT("CCallable") cCallableClassKey
 305 cReturnableClassName          = clsQual pREL_GHC_Name SLIT("CReturnable") cReturnableClassKey
 306
 307 -- PrelBase data types and constructors
 308 charTyConName     = tcQual   pREL_BASE_Name SLIT("Char") charTyConKey
 309 charDataConName   = dataQual pREL_BASE_Name SLIT("C#") charDataConKey
 310 intTyConName      = tcQual   pREL_BASE_Name SLIT("Int") intTyConKey
 311 intDataConName    = dataQual pREL_BASE_Name SLIT("I#") intDataConKey
 312 orderingTyConName = tcQual   pREL_BASE_Name SLIT("Ordering") orderingTyConKey
 313 boolTyConName     = tcQual   pREL_BASE_Name SLIT("Bool") boolTyConKey
 314 falseDataConName  = dataQual pREL_BASE_Name SLIT("False") falseDataConKey
 315 trueDataConName   = dataQual pREL_BASE_Name SLIT("True") trueDataConKey
 316 listTyConName     = tcQual   pREL_BASE_Name SLIT("[]") listTyConKey
 317 nilDataConName    = dataQual pREL_BASE_Name SLIT("[]") nilDataConKey
 318 consDataConName   = dataQual pREL_BASE_Name SLIT(":") consDataConKey
 319
 320 -- Generics
 321 crossTyConName     = tcQual   pREL_BASE_Name SLIT(":*:") crossTyConKey
 322 crossDataConName   = dataQual pREL_BASE_Name SLIT(":*:") crossDataConKey
 323 plusTyConName      = tcQual   pREL_BASE_Name SLIT(":+:") plusTyConKey
 324 inlDataConName     = dataQual pREL_BASE_Name SLIT("Inl") inlDataConKey
 325 inrDataConName     = dataQual pREL_BASE_Name SLIT("Inr") inrDataConKey
 326 genUnitTyConName   = tcQual   pREL_BASE_Name SLIT("Unit") genUnitTyConKey
 327 genUnitDataConName = dataQual pREL_BASE_Name SLIT("Unit") genUnitDataConKey
 328
 329 -- Random PrelBase functions
 330 otherwiseIdName   = varQual pREL_BASE_Name SLIT("otherwise") otherwiseIdKey
 331 appendName        = varQual pREL_BASE_Name SLIT("++") appendIdKey
 332 foldrName         = varQual pREL_BASE_Name SLIT("foldr") foldrIdKey
 333 mapName           = varQual pREL_BASE_Name SLIT("map") mapIdKey
 334 buildName         = varQual pREL_BASE_Name SLIT("build") buildIdKey
 335 augmentName       = varQual pREL_BASE_Name SLIT("augment") augmentIdKey
 336 eqStringName      = varQual pREL_BASE_Name SLIT("eqString") eqStringIdKey
 337
 338 -- Strings
 339 unpackCStringName       = varQual pREL_BASE_Name SLIT("unpackCString#") unpackCStringIdKey
 340 unpackCStringAppendName = varQual pREL_BASE_Name SLIT("unpackAppendCString#") unpackCStringAppendIdKey
 341 unpackCStringFoldrName  = varQual pREL_BASE_Name SLIT("unpackFoldrCString#") unpackCStringFoldrIdKey
 342 unpackCStringUtf8Name   = varQual pREL_BASE_Name SLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey
 343
 344 -- Classes Eq and Ord
 345 eqClassName       = clsQual pREL_BASE_Name SLIT("Eq") eqClassKey
 346 ordClassName      = clsQual pREL_BASE_Name SLIT("Ord") ordClassKey
 347 eqName            = varQual  pREL_BASE_Name SLIT("==") eqClassOpKey
 348 geName            = varQual  pREL_BASE_Name SLIT(">=") geClassOpKey
 349
 350 -- Class Monad
 351 monadClassName     = clsQual pREL_BASE_Name SLIT("Monad") monadClassKey
 352 monadPlusClassName = clsQual pREL_BASE_Name SLIT("MonadPlus") monadPlusClassKey
 353 thenMName          = varQual pREL_BASE_Name SLIT(">>=") thenMClassOpKey
 354 returnMName        = varQual pREL_BASE_Name SLIT("return") returnMClassOpKey
 355 failMName          = varQual pREL_BASE_Name SLIT("fail") failMClassOpKey
 356
 357 -- Class Functor
 358 functorClassName  = clsQual pREL_BASE_Name SLIT("Functor") functorClassKey
 359
 360 -- Class Show
 361 showClassName     = clsQual pREL_SHOW_Name SLIT("Show") showClassKey
 362
 363 -- Class Read
 364 readClassName     = clsQual pREL_READ_Name SLIT("Read") readClassKey
 365
 366 -- Module PrelNum
 367 numClassName      = clsQual pREL_NUM_Name SLIT("Num") numClassKey
 368 fromIntName       = varQual pREL_NUM_Name SLIT("fromInt") fromIntClassOpKey
 369 fromIntegerName   = varQual pREL_NUM_Name SLIT("fromInteger") fromIntegerClassOpKey
 370 minusName         = varQual pREL_NUM_Name SLIT("-") minusClassOpKey
 371 plusIntegerName   = varQual pREL_NUM_Name SLIT("plusInteger") plusIntegerIdKey
 372 timesIntegerName  = varQual pREL_NUM_Name SLIT("timesInteger") timesIntegerIdKey
 373 integerTyConName  = tcQual  pREL_NUM_Name SLIT("Integer") integerTyConKey
 374 smallIntegerDataConName = dataQual pREL_NUM_Name SLIT("S#") smallIntegerDataConKey
 375 largeIntegerDataConName = dataQual pREL_NUM_Name SLIT("J#") largeIntegerDataConKey
 376
 377 -- PrelReal types and classes
 378 rationalTyConName   = tcQual   pREL_REAL_Name  SLIT("Rational") rationalTyConKey
 379 ratioTyConName      = tcQual   pREL_REAL_Name  SLIT("Ratio") ratioTyConKey
 380 ratioDataConName    = dataQual pREL_REAL_Name  SLIT(":%") ratioDataConKey
 381 realClassName       = clsQual  pREL_REAL_Name  SLIT("Real") realClassKey
 382 integralClassName   = clsQual  pREL_REAL_Name  SLIT("Integral") integralClassKey
 383 realFracClassName   = clsQual  pREL_REAL_Name  SLIT("RealFrac") realFracClassKey
 384 fractionalClassName = clsQual  pREL_REAL_Name  SLIT("Fractional") fractionalClassKey
 385 fromRationalName    = varQual  pREL_REAL_Name  SLIT("fromRational") fromRationalClassOpKey
 386
 387 -- PrelFloat classes
 388 floatTyConName     = tcQual   pREL_FLOAT_Name SLIT("Float") floatTyConKey
 389 floatDataConName   = dataQual pREL_FLOAT_Name SLIT("F#") floatDataConKey
 390 doubleTyConName    = tcQual   pREL_FLOAT_Name SLIT("Double") doubleTyConKey
 391 doubleDataConName  = dataQual pREL_FLOAT_Name SLIT("D#") doubleDataConKey
 392 floatingClassName  = clsQual  pREL_FLOAT_Name SLIT("Floating") floatingClassKey
 393 realFloatClassName = clsQual  pREL_FLOAT_Name SLIT("RealFloat") realFloatClassKey
 394
 395 -- Class Ix
 396 ixClassName        = clsQual pREL_ARR_Name SLIT("Ix") ixClassKey
 397
 398 -- Class Enum
 399 enumClassName      = clsQual pREL_ENUM_Name SLIT("Enum") enumClassKey
 400 toEnumName         = varQual pREL_ENUM_Name SLIT("toEnum") toEnumClassOpKey
 401 fromEnumName       = varQual pREL_ENUM_Name SLIT("fromEnum") fromEnumClassOpKey
 402 enumFromName       = varQual pREL_ENUM_Name SLIT("enumFrom") enumFromClassOpKey
 403 enumFromToName     = varQual pREL_ENUM_Name SLIT("enumFromTo") enumFromToClassOpKey
 404 enumFromThenName   = varQual pREL_ENUM_Name SLIT("enumFromThen") enumFromThenClassOpKey
 405 enumFromThenToName = varQual pREL_ENUM_Name SLIT("enumFromThenTo") enumFromThenToClassOpKey
 406
 407 -- Class Bounded
 408 boundedClassName  = clsQual pREL_ENUM_Name SLIT("Bounded") boundedClassKey
 409
 410 -- List functions
 411 concatName        = varQual pREL_LIST_Name SLIT("concat") concatIdKey
 412 filterName        = varQual pREL_LIST_Name SLIT("filter") filterIdKey
 413 zipName           = varQual pREL_LIST_Name SLIT("zip") zipIdKey
 414
 415 -- IOBase things
 416 ioTyConName       = tcQual   pREL_IO_BASE_Name SLIT("IO") ioTyConKey
 417 ioDataConName     = dataQual pREL_IO_BASE_Name SLIT("IO") ioDataConKey
 418 bindIOName        = varQual  pREL_IO_BASE_Name SLIT("bindIO") bindIOIdKey
 419 returnIOName      = varQual  pREL_IO_BASE_Name SLIT("returnIO") returnIOIdKey
 420
 421 -- Int, Word, and Addr things
 422 int8TyConName     = tcQual iNT_Name       SLIT("Int8") int8TyConKey
 423 int16TyConName    = tcQual iNT_Name       SLIT("Int16") int16TyConKey
 424 int32TyConName    = tcQual iNT_Name       SLIT("Int32") int32TyConKey
 425 int64TyConName    = tcQual pREL_ADDR_Name SLIT("Int64") int64TyConKey
 426
 427 wordTyConName     = tcQual   pREL_ADDR_Name SLIT("Word") wordTyConKey
 428 wordDataConName   = dataQual pREL_ADDR_Name SLIT("W#") wordDataConKey
 429 word8TyConName    = tcQual   wORD_Name      SLIT("Word8") word8TyConKey
 430 word16TyConName   = tcQual   wORD_Name      SLIT("Word16") word16TyConKey
 431 word32TyConName   = tcQual   wORD_Name      SLIT("Word32") word32TyConKey
 432 word64TyConName   = tcQual   pREL_ADDR_Name SLIT("Word64") word64TyConKey
 433
 434 addrTyConName     = tcQual   pREL_ADDR_Name SLIT("Addr") addrTyConKey
 435 addrDataConName   = dataQual pREL_ADDR_Name SLIT("A#") addrDataConKey
 436
 437
 438 -- Byte array types
 439 byteArrayTyConName        = tcQual pREL_BYTEARR_Name  SLIT("ByteArray") byteArrayTyConKey
 440 mutableByteArrayTyConName = tcQual pREL_BYTEARR_Name  SLIT("MutableByteArray") mutableByteArrayTyConKey
 441
 442 -- Forign objects and weak pointers
 443 foreignObjTyConName   = tcQual   pREL_IO_BASE_Name SLIT("ForeignObj") foreignObjTyConKey
 444 foreignObjDataConName = dataQual pREL_IO_BASE_Name SLIT("ForeignObj") foreignObjDataConKey
 445 stablePtrTyConName    = tcQual   pREL_STABLE_Name SLIT("StablePtr") stablePtrTyConKey
 446 stablePtrDataConName  = dataQual pREL_STABLE_Name SLIT("StablePtr") stablePtrDataConKey
 447 deRefStablePtrName    = varQual  pREL_STABLE_Name SLIT("deRefStablePtr") deRefStablePtrIdKey
 448 newStablePtrName      = varQual  pREL_STABLE_Name SLIT("newStablePtr") newStablePtrIdKey
 449
 450 errorName          = varQual pREL_ERR_Name SLIT("error") errorIdKey
 451 assertName         = varQual pREL_GHC_Name SLIT("assert") assertIdKey
 452 getTagName         = varQual pREL_GHC_Name SLIT("getTag#") getTagIdKey
 453 runSTRepName       = varQual pREL_ST_Name  SLIT("runSTRep") runSTRepIdKey
 454 \end{code}
 455
 456 %************************************************************************
 457 %*                                                                      *
 458 \subsection{Known names}
 459 %*                                                                      *
 460 %************************************************************************
 461
 462 The following names are known to the compiler, but they don't require
 463 pre-assigned keys.  Mostly these names are used in generating deriving
 464 code, which is passed through the renamer anyway.
 465
 466         THEY ARE ALL ORIGINAL NAMES, HOWEVER
 467
 468 \begin{code}
 469 -- Lists and tuples
 470 tupleCon_RDR, tupleTyCon_RDR            :: Int -> RdrName
 471 ubxTupleCon_RDR, ubxTupleTyCon_RDR      :: Int -> RdrName
 472
 473 tupleCon_RDR      = mkTupConRdrName dataName Boxed
 474 tupleTyCon_RDR    = mkTupConRdrName tcName   Boxed
 475 ubxTupleCon_RDR   = mkTupConRdrName dataName Unboxed
 476 ubxTupleTyCon_RDR = mkTupConRdrName tcName   Unboxed
 477
 478 unitCon_RDR       = dataQual_RDR pREL_BASE_Name SLIT("()")
 479 unitTyCon_RDR     = tcQual_RDR   pREL_BASE_Name SLIT("()")
 480
 481 and_RDR            = varQual_RDR  pREL_BASE_Name SLIT("&&")
 482 not_RDR            = varQual_RDR  pREL_BASE_Name SLIT("not")
 483 compose_RDR        = varQual_RDR  pREL_BASE_Name SLIT(".")
 484 ne_RDR             = varQual_RDR  pREL_BASE_Name SLIT("/=")
 485 le_RDR             = varQual_RDR  pREL_BASE_Name SLIT("<=")
 486 lt_RDR             = varQual_RDR  pREL_BASE_Name SLIT("<")
 487 gt_RDR             = varQual_RDR  pREL_BASE_Name SLIT(">")
 488 ltTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("LT")
 489 eqTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("EQ")
 490 gtTag_RDR          = dataQual_RDR pREL_BASE_Name SLIT("GT")
 491 max_RDR            = varQual_RDR  pREL_BASE_Name SLIT("max")
 492 min_RDR            = varQual_RDR  pREL_BASE_Name SLIT("min")
 493 compare_RDR        = varQual_RDR  pREL_BASE_Name SLIT("compare")
 494 showList_RDR       = varQual_RDR  pREL_SHOW_Name SLIT("showList")
 495 showList___RDR     = varQual_RDR  pREL_SHOW_Name SLIT("showList__")
 496 showsPrec_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showsPrec")
 497 showSpace_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showSpace")
 498 showString_RDR     = varQual_RDR  pREL_SHOW_Name SLIT("showString")
 499 showParen_RDR      = varQual_RDR  pREL_SHOW_Name SLIT("showParen")
 500 readsPrec_RDR      = varQual_RDR  pREL_READ_Name SLIT("readsPrec")
 501 readList_RDR       = varQual_RDR  pREL_READ_Name SLIT("readList")
 502 readParen_RDR      = varQual_RDR  pREL_READ_Name SLIT("readParen")
 503 lex_RDR            = varQual_RDR  pREL_READ_Name SLIT("lex")
 504 readList___RDR     = varQual_RDR  pREL_READ_Name SLIT("readList__")
 505 times_RDR          = varQual_RDR  pREL_NUM_Name SLIT("*")
 506 plus_RDR           = varQual_RDR  pREL_NUM_Name SLIT("+")
 507 negate_RDR         = varQual_RDR  pREL_NUM_Name SLIT("negate")
 508 range_RDR          = varQual_RDR  pREL_ARR_Name SLIT("range")
 509 index_RDR          = varQual_RDR  pREL_ARR_Name SLIT("index")
 510 inRange_RDR        = varQual_RDR  pREL_ARR_Name SLIT("inRange")
 511 succ_RDR           = varQual_RDR  pREL_ENUM_Name SLIT("succ")
 512 pred_RDR           = varQual_RDR  pREL_ENUM_Name SLIT("pred")
 513 minBound_RDR       = varQual_RDR  pREL_ENUM_Name SLIT("minBound")
 514 maxBound_RDR       = varQual_RDR  pREL_ENUM_Name SLIT("maxBound")
 515 assertErr_RDR      = varQual_RDR  pREL_ERR_Name SLIT("assertError")
 516 \end{code}
 517
 518 These RDR names also have known keys, so we need to get back the RDR names to
 519 populate the occurrence list above.
 520
 521 \begin{code}
 522 funTyCon_RDR            = nameRdrName funTyConName
 523 nilCon_RDR              = nameRdrName nilDataConName
 524 listTyCon_RDR           = nameRdrName listTyConName
 525 ioTyCon_RDR             = nameRdrName ioTyConName
 526 intTyCon_RDR            = nameRdrName intTyConName
 527 eq_RDR                  = nameRdrName eqName
 528 ge_RDR                  = nameRdrName geName
 529 numClass_RDR            = nameRdrName numClassName
 530 ordClass_RDR            = nameRdrName ordClassName
 531 map_RDR                 = nameRdrName mapName
 532 append_RDR              = nameRdrName appendName
 533 foldr_RDR               = nameRdrName foldrName
 534 build_RDR               = nameRdrName buildName
 535 enumFromTo_RDR          = nameRdrName enumFromToName
 536 returnM_RDR             = nameRdrName returnMName
 537 thenM_RDR               = nameRdrName thenMName
 538 failM_RDR               = nameRdrName failMName
 539 false_RDR               = nameRdrName falseDataConName
 540 true_RDR                = nameRdrName trueDataConName
 541 error_RDR               = nameRdrName errorName
 542 getTag_RDR              = nameRdrName getTagName
 543 fromEnum_RDR            = nameRdrName fromEnumName
 544 toEnum_RDR              = nameRdrName toEnumName
 545 enumFrom_RDR            = nameRdrName enumFromName
 546 mkInt_RDR               = nameRdrName intDataConName
 547 enumFromThen_RDR        = nameRdrName enumFromThenName
 548 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 549 ratioDataCon_RDR        = nameRdrName ratioDataConName
 550 plusInteger_RDR         = nameRdrName plusIntegerName
 551 timesInteger_RDR        = nameRdrName timesIntegerName
 552 enumClass_RDR           = nameRdrName enumClassName
 553 monadClass_RDR          = nameRdrName monadClassName
 554 ioDataCon_RDR           = nameRdrName ioDataConName
 555 cCallableClass_RDR      = nameRdrName cCallableClassName
 556 cReturnableClass_RDR    = nameRdrName cReturnableClassName
 557 eqClass_RDR             = nameRdrName eqClassName
 558 eqString_RDR            = nameRdrName eqStringName
 559 unpackCString_RDR       = nameRdrName unpackCStringName
 560 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 561 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 562 deRefStablePtr_RDR      = nameRdrName deRefStablePtrName
 563 newStablePtr_RDR        = nameRdrName newStablePtrName
 564 bindIO_RDR              = nameRdrName bindIOName
 565 returnIO_RDR            = nameRdrName returnIOName
 566 fromInteger_RDR         = nameRdrName fromIntegerName
 567 fromRational_RDR        = nameRdrName fromRationalName
 568 minus_RDR               = nameRdrName minusName
 569 \end{code}
 570
 571 %************************************************************************
 572 %*                                                                      *
 573 \subsection{Local helpers}
 574 %*                                                                      *
 575 %************************************************************************
 576
 577 All these are original names; hence mkOrig
 578
 579 \begin{code}
 580 varQual  mod str uq = mkKnownKeyGlobal (varQual_RDR  mod str) uq
 581 dataQual mod str uq = mkKnownKeyGlobal (dataQual_RDR mod str) uq
 582 tcQual   mod str uq = mkKnownKeyGlobal (tcQual_RDR   mod str) uq
 583 clsQual  mod str uq = mkKnownKeyGlobal (clsQual_RDR  mod str) uq
 584
 585 kindQual str uq = mkLocalName (mkKindOccFS tcName str) uq
 586         -- Kinds are not z-encoded in interface file, hence mkKindOccFS
 587         -- And they don't come from any particular module; indeed we always
 588         -- want to print them unqualified.  Hence the LocalName
 589
 590 varQual_RDR  mod str = mkOrig varName  mod str
 591 tcQual_RDR   mod str = mkOrig tcName   mod str
 592 clsQual_RDR  mod str = mkOrig clsName  mod str
 593 dataQual_RDR mod str = mkOrig dataName mod str
 594 \end{code}
 595
 596 %************************************************************************
 597 %*                                                                      *
 598 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 599 %*                                                                      *
 600 %************************************************************************
 601
 602 \begin{code}
 603 boundedClassKey         = mkPreludeClassUnique 1
 604 enumClassKey            = mkPreludeClassUnique 2
 605 eqClassKey              = mkPreludeClassUnique 3
 606 floatingClassKey        = mkPreludeClassUnique 5
 607 fractionalClassKey      = mkPreludeClassUnique 6
 608 integralClassKey        = mkPreludeClassUnique 7
 609 monadClassKey           = mkPreludeClassUnique 8
 610 monadPlusClassKey       = mkPreludeClassUnique 9
 611 functorClassKey         = mkPreludeClassUnique 10
 612 numClassKey             = mkPreludeClassUnique 11
 613 ordClassKey             = mkPreludeClassUnique 12
 614 readClassKey            = mkPreludeClassUnique 13
 615 realClassKey            = mkPreludeClassUnique 14
 616 realFloatClassKey       = mkPreludeClassUnique 15
 617 realFracClassKey        = mkPreludeClassUnique 16
 618 showClassKey            = mkPreludeClassUnique 17
 619
 620 cCallableClassKey       = mkPreludeClassUnique 18
 621 cReturnableClassKey     = mkPreludeClassUnique 19
 622
 623 ixClassKey              = mkPreludeClassUnique 20
 624 \end{code}
 625
 626 %************************************************************************
 627 %*                                                                      *
 628 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 629 %*                                                                      *
 630 %************************************************************************
 631
 632 \begin{code}
 633 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 634 addrTyConKey                            = mkPreludeTyConUnique  2
 635 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 636 boolTyConKey                            = mkPreludeTyConUnique  4
 637 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 638 charPrimTyConKey                        = mkPreludeTyConUnique  7
 639 charTyConKey                            = mkPreludeTyConUnique  8
 640 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 641 doubleTyConKey                          = mkPreludeTyConUnique 10
 642 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 643 floatTyConKey                           = mkPreludeTyConUnique 12
 644 funTyConKey                             = mkPreludeTyConUnique 13
 645 intPrimTyConKey                         = mkPreludeTyConUnique 14
 646 intTyConKey                             = mkPreludeTyConUnique 15
 647 int8TyConKey                            = mkPreludeTyConUnique 16
 648 int16TyConKey                           = mkPreludeTyConUnique 17
 649 int32TyConKey                           = mkPreludeTyConUnique 18
 650 int64PrimTyConKey                       = mkPreludeTyConUnique 19
 651 int64TyConKey                           = mkPreludeTyConUnique 20
 652 integerTyConKey                         = mkPreludeTyConUnique 21
 653 listTyConKey                            = mkPreludeTyConUnique 22
 654 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 23
 655 foreignObjTyConKey                      = mkPreludeTyConUnique 24
 656 weakPrimTyConKey                        = mkPreludeTyConUnique 25
 657 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 26
 658 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 27
 659 orderingTyConKey                        = mkPreludeTyConUnique 28
 660 mVarPrimTyConKey                        = mkPreludeTyConUnique 29
 661 ratioTyConKey                           = mkPreludeTyConUnique 30
 662 rationalTyConKey                        = mkPreludeTyConUnique 31
 663 realWorldTyConKey                       = mkPreludeTyConUnique 32
 664 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 33
 665 stablePtrTyConKey                       = mkPreludeTyConUnique 34
 666 statePrimTyConKey                       = mkPreludeTyConUnique 35
 667 stableNamePrimTyConKey                  = mkPreludeTyConUnique 50
 668 stableNameTyConKey                      = mkPreludeTyConUnique 51
 669 mutableByteArrayTyConKey                = mkPreludeTyConUnique 52
 670 mutVarPrimTyConKey                      = mkPreludeTyConUnique 53
 671 ioTyConKey                              = mkPreludeTyConUnique 55
 672 byteArrayTyConKey                       = mkPreludeTyConUnique 56
 673 wordPrimTyConKey                        = mkPreludeTyConUnique 57
 674 wordTyConKey                            = mkPreludeTyConUnique 58
 675 word8TyConKey                           = mkPreludeTyConUnique 59
 676 word16TyConKey                          = mkPreludeTyConUnique 60
 677 word32TyConKey                          = mkPreludeTyConUnique 61
 678 word64PrimTyConKey                      = mkPreludeTyConUnique 62
 679 word64TyConKey                          = mkPreludeTyConUnique 63
 680 boxedConKey                             = mkPreludeTyConUnique 64
 681 unboxedConKey                           = mkPreludeTyConUnique 65
 682 anyBoxConKey                            = mkPreludeTyConUnique 66
 683 kindConKey                              = mkPreludeTyConUnique 67
 684 boxityConKey                            = mkPreludeTyConUnique 68
 685 typeConKey                              = mkPreludeTyConUnique 69
 686 threadIdPrimTyConKey                    = mkPreludeTyConUnique 70
 687 bcoPrimTyConKey                         = mkPreludeTyConUnique 71
 688
 689 -- Usage type constructors
 690 usageConKey                             = mkPreludeTyConUnique 72
 691 usOnceTyConKey                          = mkPreludeTyConUnique 73
 692 usManyTyConKey                          = mkPreludeTyConUnique 74
 693
 694 -- Generic Type Constructors
 695 crossTyConKey                           = mkPreludeTyConUnique 75
 696 plusTyConKey                            = mkPreludeTyConUnique 76
 697 genUnitTyConKey                         = mkPreludeTyConUnique 77
 698 \end{code}
 699
 700 %************************************************************************
 701 %*                                                                      *
 702 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
 703 %*                                                                      *
 704 %************************************************************************
 705
 706 \begin{code}
 707 addrDataConKey                          = mkPreludeDataConUnique  0
 708 charDataConKey                          = mkPreludeDataConUnique  1
 709 consDataConKey                          = mkPreludeDataConUnique  2
 710 doubleDataConKey                        = mkPreludeDataConUnique  3
 711 falseDataConKey                         = mkPreludeDataConUnique  4
 712 floatDataConKey                         = mkPreludeDataConUnique  5
 713 intDataConKey                           = mkPreludeDataConUnique  6
 714 smallIntegerDataConKey                  = mkPreludeDataConUnique  7
 715 largeIntegerDataConKey                  = mkPreludeDataConUnique  8
 716 foreignObjDataConKey                    = mkPreludeDataConUnique  9
 717 nilDataConKey                           = mkPreludeDataConUnique 10
 718 ratioDataConKey                         = mkPreludeDataConUnique 11
 719 stablePtrDataConKey                     = mkPreludeDataConUnique 12
 720 stableNameDataConKey                    = mkPreludeDataConUnique 13
 721 trueDataConKey                          = mkPreludeDataConUnique 14
 722 wordDataConKey                          = mkPreludeDataConUnique 15
 723 ioDataConKey                            = mkPreludeDataConUnique 16
 724
 725 -- Generic data constructors
 726 crossDataConKey                         = mkPreludeDataConUnique 17
 727 inlDataConKey                           = mkPreludeDataConUnique 18
 728 inrDataConKey                           = mkPreludeDataConUnique 19
 729 genUnitDataConKey                       = mkPreludeDataConUnique 20
 730 \end{code}
 731
 732 %************************************************************************
 733 %*                                                                      *
 734 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
 735 %*                                                                      *
 736 %************************************************************************
 737
 738 \begin{code}
 739 absentErrorIdKey              = mkPreludeMiscIdUnique  1
 740 appendIdKey                   = mkPreludeMiscIdUnique  2
 741 augmentIdKey                  = mkPreludeMiscIdUnique  3
 742 buildIdKey                    = mkPreludeMiscIdUnique  4
 743 errorIdKey                    = mkPreludeMiscIdUnique  5
 744 foldlIdKey                    = mkPreludeMiscIdUnique  6
 745 foldrIdKey                    = mkPreludeMiscIdUnique  7
 746 recSelErrIdKey                = mkPreludeMiscIdUnique  8
 747 integerMinusOneIdKey          = mkPreludeMiscIdUnique  9
 748 integerPlusOneIdKey           = mkPreludeMiscIdUnique 10
 749 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 11
 750 integerZeroIdKey              = mkPreludeMiscIdUnique 12
 751 int2IntegerIdKey              = mkPreludeMiscIdUnique 13
 752 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 15
 753 eqStringIdKey                 = mkPreludeMiscIdUnique 16
 754 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 17
 755 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 18
 756 parErrorIdKey                 = mkPreludeMiscIdUnique 20
 757 parIdKey                      = mkPreludeMiscIdUnique 21
 758 patErrorIdKey                 = mkPreludeMiscIdUnique 22
 759 realWorldPrimIdKey            = mkPreludeMiscIdUnique 23
 760 recConErrorIdKey              = mkPreludeMiscIdUnique 24
 761 recUpdErrorIdKey              = mkPreludeMiscIdUnique 25
 762 traceIdKey                    = mkPreludeMiscIdUnique 26
 763 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 27
 764 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 28
 765 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 29
 766 unpackCStringIdKey            = mkPreludeMiscIdUnique 30
 767 ushowListIdKey                = mkPreludeMiscIdUnique 31
 768 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
 769 concatIdKey                   = mkPreludeMiscIdUnique 33
 770 filterIdKey                   = mkPreludeMiscIdUnique 34
 771 zipIdKey                      = mkPreludeMiscIdUnique 35
 772 bindIOIdKey                   = mkPreludeMiscIdUnique 36
 773 returnIOIdKey                 = mkPreludeMiscIdUnique 37
 774 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
 775 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
 776 getTagIdKey                   = mkPreludeMiscIdUnique 40
 777 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
 778 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
 779 \end{code}
 780
 781 Certain class operations from Prelude classes.  They get their own
 782 uniques so we can look them up easily when we want to conjure them up
 783 during type checking.
 784
 785 \begin{code}
 786 fromIntClassOpKey             = mkPreludeMiscIdUnique 101
 787 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
 788 minusClassOpKey               = mkPreludeMiscIdUnique 103
 789 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
 790 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
 791 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
 792 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
 793 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
 794 eqClassOpKey                  = mkPreludeMiscIdUnique 109
 795 geClassOpKey                  = mkPreludeMiscIdUnique 110
 796 failMClassOpKey               = mkPreludeMiscIdUnique 112
 797 thenMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
 798         -- Just a place holder for  unbound variables  produced by the renamer:
 799 unboundKey                    = mkPreludeMiscIdUnique 114
 800 fromEnumClassOpKey            = mkPreludeMiscIdUnique 115
 801
 802 mainKey                       = mkPreludeMiscIdUnique 116
 803 returnMClassOpKey             = mkPreludeMiscIdUnique 117
 804 otherwiseIdKey                = mkPreludeMiscIdUnique 118
 805 toEnumClassOpKey              = mkPreludeMiscIdUnique 119
 806 mapIdKey                      = mkPreludeMiscIdUnique 120
 807 \end{code}
 808
 809 \begin{code}
 810 assertIdKey                   = mkPreludeMiscIdUnique 121
 811 runSTRepIdKey                 = mkPreludeMiscIdUnique 122
 812 \end{code}
 813
 814
 815 %************************************************************************
 816 %*                                                                      *
 817 \subsection{Standard groups of types}
 818 %*                                                                      *
 819 %************************************************************************
 820
 821 \begin{code}
 822 numericTyKeys =
 823         [ addrTyConKey
 824         , wordTyConKey
 825         , intTyConKey
 826         , integerTyConKey
 827         , doubleTyConKey
 828         , floatTyConKey
 829         ]
 830
 831         -- Renamer always imports these data decls replete with constructors
 832         -- so that desugarer can always see their constructors.  Ugh!
 833 cCallishTyKeys =
 834         [ addrTyConKey
 835         , wordTyConKey
 836         , byteArrayTyConKey
 837         , mutableByteArrayTyConKey
 838         , foreignObjTyConKey
 839         , stablePtrTyConKey
 840         , int8TyConKey
 841         , int16TyConKey
 842         , int32TyConKey
 843         , int64TyConKey
 844         , word8TyConKey
 845         , word16TyConKey
 846         , word32TyConKey
 847         , word64TyConKey
 848         ]
 849 \end{code}
 850
 851
 852 %************************************************************************
 853 %*                                                                      *
 854 \subsection[Class-std-groups]{Standard groups of Prelude classes}
 855 %*                                                                      *
 856 %************************************************************************
 857
 858 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
 859 (@TcDeriv@).
 860
 861 @derivingOccurrences@ maps a class name to a list of the (qualified)
 862 occurrences that will be mentioned by the derived code for the class
 863 when it is later generated.  We don't need to put in things that are
 864 WiredIn (because they are already mapped to their correct name by the
 865 @NameSupply@.  The class itself, and all its class ops, is already
 866 flagged as an occurrence so we don't need to mention that either.
 867
 868 @derivingOccurrences@ has an item for every derivable class, even if
 869 that item is empty, because we treat lookup failure as indicating that
 870 the class is illegal in a deriving clause.
 871
 872 \begin{code}
 873 derivingOccurrences :: UniqFM [RdrName]
 874 derivingOccurrences = listToUFM deriving_occ_info
 875
 876 derivableClassKeys  = map fst deriving_occ_info
 877
 878 deriving_occ_info
 879   = [ (eqClassKey,      [intTyCon_RDR, and_RDR, not_RDR])
 880     , (ordClassKey,     [intTyCon_RDR, compose_RDR, eqTag_RDR])
 881                                 -- EQ (from Ordering) is needed to force in the constructors
 882                                 -- as well as the type constructor.
 883     , (enumClassKey,    [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
 884                                 -- The last two Enum deps are only used to produce better
 885                                 -- error msgs for derived toEnum methods.
 886     , (boundedClassKey, [intTyCon_RDR])
 887     , (showClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
 888                          showParen_RDR, showSpace_RDR, showList___RDR])
 889     , (readClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
 890                          foldr_RDR, build_RDR,
 891                              -- foldr and build required for list comprehension
 892                              -- KSW 2000-06
 893                          lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
 894                              -- returnM (and the rest of the Monad class decl)
 895                              -- will be forced in as result of depending
 896                              -- on thenM.   -- SOF 1/99
 897     , (ixClassKey,      [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
 898                          foldr_RDR, build_RDR,
 899                              -- foldr and build required for list comprehension used
 900                              -- with single constructor types  -- KSW 2000-06
 901                          returnM_RDR, failM_RDR])
 902                              -- the last two are needed to force returnM, thenM and failM
 903                              -- in before typechecking the list(monad) comprehension
 904                              -- generated for derived Ix instances (range method)
 905                              -- of single constructor types.  -- SOF 8/97
 906     ]
 907         -- intTyCon: Practically any deriving needs Int, either for index calculations,
 908         --              or for taggery.
 909         -- ordClass: really it's the methods that are actually used.
 910         -- numClass: for Int literals
 911 \end{code}
 912
 913
 914 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
 915 even though every numeric class has these two as a superclass,
 916 because the list of ambiguous dictionaries hasn't been simplified.
 917
 918 \begin{code}
 919 numericClassKeys =
 920         [ numClassKey
 921         , realClassKey
 922         , integralClassKey
 923         ]
 924         ++ fractionalClassKeys
 925
 926 fractionalClassKeys =
 927         [ fractionalClassKey
 928         , floatingClassKey
 929         , realFracClassKey
 930         , realFloatClassKey
 931         ]
 932
 933         -- the strictness analyser needs to know about numeric types
 934         -- (see SaAbsInt.lhs)
 935 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
 936         [ readClassKey
 937         ]
 938
 939 cCallishClassKeys =
 940         [ cCallableClassKey
 941         , cReturnableClassKey
 942         ]
 943
 944 standardClassKeys
 945   = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
 946     --
 947     -- We have to have "CCallable" and "CReturnable" in the standard
 948     -- classes, so that if you go...
 949     --
 950     --      _ccall_ foo ... 93{-numeric literal-} ...
 951     --
 952     -- ... it can do The Right Thing on the 93.
 953
 954 noDictClassKeys         -- These classes are used only for type annotations;
 955                         -- they are not implemented by dictionaries, ever.
 956   = cCallishClassKeys
 957 \end{code}
 958
 959 \begin{code}
 960 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
 961 -- during compiler debugging.
 962 mkUnboundName :: RdrName -> Name
 963 mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
 964
 965 isUnboundName :: Name -> Bool
 966 isUnboundName name = name `hasKey` unboundKey
 967 \end{code}