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