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