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