compiler/prelude/PrelNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelNames]{Definitions of prelude modules and names}
   5
   6
   7 Nota Bene: all Names defined in here should come from the base package
   8
   9  - ModuleNames for prelude modules,
  10         e.g.    pREL_BASE_Name :: ModuleName
  11
  12  - Modules for prelude modules
  13         e.g.    pREL_Base :: Module
  14
  15  - Uniques for Ids, DataCons, TyCons and Classes that the compiler
  16    "knows about" in some way
  17         e.g.    intTyConKey :: Unique
  18                 minusClassOpKey :: Unique
  19
  20  - Names for Ids, DataCons, TyCons and Classes that the compiler
  21    "knows about" in some way
  22         e.g.    intTyConName :: Name
  23                 minusName    :: Name
  24    One of these Names contains
  25         (a) the module and occurrence name of the thing
  26         (b) its Unique
  27    The may way the compiler "knows about" one of these things is
  28    where the type checker or desugarer needs to look it up. For
  29    example, when desugaring list comprehensions the desugarer
  30    needs to conjure up 'foldr'.  It does this by looking up
  31    foldrName in the environment.
  32
  33  - RdrNames for Ids, DataCons etc that the compiler may emit into
  34    generated code (e.g. for deriving).  It's not necessary to know
  35    the uniques for these guys, only their names
  36
  37
  38 \begin{code}
  39 module PrelNames (
  40         Unique, Uniquable(..), hasKey,  -- Re-exported for convenience
  41
  42         -----------------------------------------------------------
  43         module PrelNames,       -- A huge bunch of (a) Names,  e.g. intTyConName
  44                                 --                 (b) Uniques e.g. intTyConKey
  45                                 --                 (c) Groups of classes and types
  46                                 --                 (d) miscellaneous things
  47                                 -- So many that we export them all
  48     ) where
  49
  50 #include "HsVersions.h"
  51
  52 import Module
  53 import OccName
  54 import RdrName    ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual )
  55 import Unique     ( Unique, Uniquable(..), hasKey,
  56                     mkPreludeMiscIdUnique, mkPreludeDataConUnique,
  57                     mkPreludeTyConUnique, mkPreludeClassUnique,
  58                     mkTupleTyConUnique
  59                   )
  60 import BasicTypes ( Boxity(..), Arity )
  61 import Name       ( Name, mkInternalName, mkExternalName, mkSystemVarName )
  62 import SrcLoc
  63 import FastString
  64 \end{code}
  65
  66
  67 %************************************************************************
  68 %*                                                                      *
  69 \subsection{Local Names}
  70 %*                                                                      *
  71 %************************************************************************
  72
  73 This *local* name is used by the interactive stuff
  74
  75 \begin{code}
  76 itName :: Unique -> Name
  77 itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan
  78 \end{code}
  79
  80 \begin{code}
  81 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
  82 -- during compiler debugging.
  83 mkUnboundName :: RdrName -> Name
  84 mkUnboundName rdr_name = mkInternalName unboundKey (rdrNameOcc rdr_name) noSrcSpan
  85
  86 isUnboundName :: Name -> Bool
  87 isUnboundName name = name `hasKey` unboundKey
  88 \end{code}
  89
  90
  91 %************************************************************************
  92 %*                                                                      *
  93 \subsection{Known key Names}
  94 %*                                                                      *
  95 %************************************************************************
  96
  97 This section tells what the compiler knows about the assocation of
  98 names with uniques.  These ones are the *non* wired-in ones.  The
  99 wired in ones are defined in TysWiredIn etc.
 100
 101 \begin{code}
 102 basicKnownKeyNames :: [Name]
 103 basicKnownKeyNames
 104  = genericTyConNames
 105  ++ typeableClassNames
 106  ++ [   -- Type constructors (synonyms especially)
 107         ioTyConName, ioDataConName,
 108         runMainIOName,
 109         orderingTyConName,
 110         rationalTyConName,
 111         stringTyConName,
 112         ratioDataConName,
 113         ratioTyConName,
 114         integerTyConName, smallIntegerName,
 115
 116         --  Classes.  *Must* include:
 117         --      classes that are grabbed by key (e.g., eqClassKey)
 118         --      classes in "Class.standardClassKeys" (quite a few)
 119         eqClassName,                    -- mentioned, derivable
 120         ordClassName,                   -- derivable
 121         boundedClassName,               -- derivable
 122         numClassName,                   -- mentioned, numeric
 123         enumClassName,                  -- derivable
 124         monadClassName,
 125         functorClassName,
 126         realClassName,                  -- numeric
 127         integralClassName,              -- numeric
 128         fractionalClassName,            -- numeric
 129         floatingClassName,              -- numeric
 130         realFracClassName,              -- numeric
 131         realFloatClassName,             -- numeric
 132         dataClassName,
 133         isStringClassName,
 134         applicativeClassName,
 135         foldableClassName,
 136         traversableClassName,
 137
 138         -- Numeric stuff
 139         negateName, minusName, geName, eqName,
 140
 141         -- Conversion functions
 142         fromRationalName, fromIntegerName,
 143         toIntegerName, toRationalName,
 144         fromIntegralName, realToFracName,
 145
 146         -- String stuff
 147         fromStringName,
 148
 149         -- Enum stuff
 150         enumFromName, enumFromThenName,
 151         enumFromThenToName, enumFromToName,
 152         enumFromToPName, enumFromThenToPName,
 153
 154         -- Monad stuff
 155         thenIOName, bindIOName, returnIOName, failIOName,
 156         failMName, bindMName, thenMName, returnMName,
 157
 158         -- MonadRec stuff
 159         mfixName,
 160
 161         -- Arrow stuff
 162         arrAName, composeAName, firstAName,
 163         appAName, choiceAName, loopAName,
 164
 165         -- Ix stuff
 166         ixClassName,
 167
 168         -- Show stuff
 169         showClassName,
 170
 171         -- Read stuff
 172         readClassName,
 173
 174         -- Stable pointers
 175         newStablePtrName,
 176
 177     -- GHC Extensions
 178         groupWithName,
 179
 180         -- Strings and lists
 181         unpackCStringName, unpackCStringAppendName,
 182         unpackCStringFoldrName, unpackCStringUtf8Name,
 183
 184         -- List operations
 185         concatName, filterName, mapName,
 186         zipName, foldrName, buildName, augmentName, appendName,
 187
 188         dollarName,         -- The ($) apply function
 189
 190         -- Parallel array operations
 191         nullPName, lengthPName, replicatePName, singletonPName, mapPName,
 192         filterPName, zipPName, crossMapPName, indexPName,
 193         toPName, emptyPName, appPName,
 194
 195         -- FFI primitive types that are not wired-in.
 196         stablePtrTyConName, ptrTyConName, funPtrTyConName,
 197         int8TyConName, int16TyConName, int32TyConName, int64TyConName,
 198         wordTyConName, word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 199
 200         -- Others
 201         otherwiseIdName, inlineIdName,
 202         plusIntegerName, timesIntegerName,
 203         eqStringName, assertName, breakpointName, breakpointCondName,
 204         breakpointAutoName,  opaqueTyConName,
 205         assertErrorName, runSTRepName,
 206         printName, fstName, sndName,
 207
 208         -- MonadFix
 209         monadFixClassName, mfixName,
 210
 211         -- Other classes
 212         randomClassName, randomGenClassName, monadPlusClassName,
 213
 214         -- Code types
 215         hetmet_brak_name, hetmet_esc_name, hetmet_csp_name,
 216         hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name,
 217                                          hetmet_guest_char_literal_name,
 218
 219         -- Annotation type checking
 220         toAnnotationWrapperName
 221
 222         -- The Either type
 223         , eitherTyConName, leftDataConName, rightDataConName
 224
 225         -- dotnet interop
 226         , objectTyConName, marshalObjectName, unmarshalObjectName
 227         , marshalStringName, unmarshalStringName, checkDotnetResName
 228     ]
 229
 230 genericTyConNames :: [Name]
 231 genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
 232 \end{code}
 233
 234
 235 %************************************************************************
 236 %*                                                                      *
 237 \subsection{Module names}
 238 %*                                                                      *
 239 %************************************************************************
 240
 241
 242 --MetaHaskell Extension Add a new module here
 243 \begin{code}
 244 pRELUDE :: Module
 245 pRELUDE         = mkBaseModule_ pRELUDE_NAME
 246
 247 gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
 248     gHC_MAGIC,
 249     gHC_CLASSES, gHC_BASE, gHC_ENUM,
 250     gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST, gHC_PARR,
 251     gHC_HETMET_CODETYPES,
 252     gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
 253     gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
 254     gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
 255     gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS,
 256     dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, cONTROL_APPLICATIVE,
 257     gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module
 258
 259 gHC_PRIM        = mkPrimModule (fsLit "GHC.Prim")   -- Primitive types and values
 260 gHC_TYPES       = mkPrimModule (fsLit "GHC.Types")
 261 gHC_UNIT        = mkPrimModule (fsLit "GHC.Unit")
 262 gHC_ORDERING    = mkPrimModule (fsLit "GHC.Ordering")
 263 gHC_GENERICS    = mkPrimModule (fsLit "GHC.Generics")
 264 gHC_MAGIC       = mkPrimModule (fsLit "GHC.Magic")
 265
 266 gHC_CLASSES     = mkBaseModule (fsLit "GHC.Classes")
 267 gHC_BASE        = mkBaseModule (fsLit "GHC.Base")
 268 gHC_ENUM        = mkBaseModule (fsLit "GHC.Enum")
 269 gHC_SHOW        = mkBaseModule (fsLit "GHC.Show")
 270 gHC_READ        = mkBaseModule (fsLit "GHC.Read")
 271 gHC_NUM         = mkBaseModule (fsLit "GHC.Num")
 272 gHC_INTEGER     = mkIntegerModule (fsLit "GHC.Integer")
 273 gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
 274 gHC_LIST        = mkBaseModule (fsLit "GHC.List")
 275 gHC_PARR        = mkBaseModule (fsLit "GHC.PArr")
 276 gHC_HETMET_CODETYPES = mkBaseModule (fsLit "GHC.HetMet.CodeTypes")
 277 gHC_TUPLE       = mkPrimModule (fsLit "GHC.Tuple")
 278 dATA_TUPLE      = mkBaseModule (fsLit "Data.Tuple")
 279 dATA_EITHER     = mkBaseModule (fsLit "Data.Either")
 280 dATA_STRING     = mkBaseModule (fsLit "Data.String")
 281 dATA_FOLDABLE   = mkBaseModule (fsLit "Data.Foldable")
 282 dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable")
 283 gHC_PACK        = mkBaseModule (fsLit "GHC.Pack")
 284 gHC_CONC        = mkBaseModule (fsLit "GHC.Conc")
 285 gHC_IO          = mkBaseModule (fsLit "GHC.IO")
 286 gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception")
 287 gHC_ST          = mkBaseModule (fsLit "GHC.ST")
 288 gHC_ARR         = mkBaseModule (fsLit "GHC.Arr")
 289 gHC_STABLE      = mkBaseModule (fsLit "GHC.Stable")
 290 gHC_ADDR        = mkBaseModule (fsLit "GHC.Addr")
 291 gHC_PTR         = mkBaseModule (fsLit "GHC.Ptr")
 292 gHC_ERR         = mkBaseModule (fsLit "GHC.Err")
 293 gHC_REAL        = mkBaseModule (fsLit "GHC.Real")
 294 gHC_FLOAT       = mkBaseModule (fsLit "GHC.Float")
 295 gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler")
 296 sYSTEM_IO       = mkBaseModule (fsLit "System.IO")
 297 dYNAMIC         = mkBaseModule (fsLit "Data.Dynamic")
 298 tYPEABLE        = mkBaseModule (fsLit "Data.Typeable")
 299 gENERICS        = mkBaseModule (fsLit "Data.Data")
 300 dOTNET          = mkBaseModule (fsLit "GHC.Dotnet")
 301 rEAD_PREC       = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec")
 302 lEX             = mkBaseModule (fsLit "Text.Read.Lex")
 303 gHC_INT         = mkBaseModule (fsLit "GHC.Int")
 304 gHC_WORD        = mkBaseModule (fsLit "GHC.Word")
 305 mONAD           = mkBaseModule (fsLit "Control.Monad")
 306 mONAD_FIX       = mkBaseModule (fsLit "Control.Monad.Fix")
 307 aRROW           = mkBaseModule (fsLit "Control.Arrow")
 308 cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative")
 309 gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar")
 310 rANDOM          = mkBaseModule (fsLit "System.Random")
 311 gHC_EXTS        = mkBaseModule (fsLit "GHC.Exts")
 312 cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base")
 313
 314 mAIN, rOOT_MAIN :: Module
 315 mAIN            = mkMainModule_ mAIN_NAME
 316 rOOT_MAIN       = mkMainModule (fsLit ":Main") -- Root module for initialisation
 317
 318         -- The ':xxx' makes a module name that the user can never
 319         -- use himself.  The z-encoding for ':' is "ZC", so the z-encoded
 320         -- module name still starts with a capital letter, which keeps
 321         -- the z-encoded version consistent.
 322 iNTERACTIVE :: Module
 323 iNTERACTIVE    = mkMainModule (fsLit ":Interactive")
 324
 325 pRELUDE_NAME, mAIN_NAME :: ModuleName
 326 pRELUDE_NAME   = mkModuleNameFS (fsLit "Prelude")
 327 mAIN_NAME      = mkModuleNameFS (fsLit "Main")
 328
 329 mkPrimModule :: FastString -> Module
 330 mkPrimModule m = mkModule primPackageId (mkModuleNameFS m)
 331
 332 mkIntegerModule :: FastString -> Module
 333 mkIntegerModule m = mkModule integerPackageId (mkModuleNameFS m)
 334
 335 mkBaseModule :: FastString -> Module
 336 mkBaseModule m = mkModule basePackageId (mkModuleNameFS m)
 337
 338 mkBaseModule_ :: ModuleName -> Module
 339 mkBaseModule_ m = mkModule basePackageId m
 340
 341 mkMainModule :: FastString -> Module
 342 mkMainModule m = mkModule mainPackageId (mkModuleNameFS m)
 343
 344 mkMainModule_ :: ModuleName -> Module
 345 mkMainModule_ m = mkModule mainPackageId m
 346 \end{code}
 347
 348 %************************************************************************
 349 %*                                                                      *
 350 \subsection{Constructing the names of tuples
 351 %*                                                                      *
 352 %************************************************************************
 353
 354 \begin{code}
 355 mkTupleModule :: Boxity -> Arity -> Module
 356 mkTupleModule Boxed   0 = gHC_UNIT
 357 mkTupleModule Boxed   _ = gHC_TUPLE
 358 mkTupleModule Unboxed _ = gHC_PRIM
 359 \end{code}
 360
 361
 362 %************************************************************************
 363 %*                                                                      *
 364                         RdrNames
 365 %*                                                                      *
 366 %************************************************************************
 367
 368 \begin{code}
 369 main_RDR_Unqual    :: RdrName
 370 main_RDR_Unqual = mkUnqual varName (fsLit "main")
 371         -- We definitely don't want an Orig RdrName, because
 372         -- main might, in principle, be imported into module Main
 373
 374 forall_tv_RDR, dot_tv_RDR :: RdrName
 375 forall_tv_RDR = mkUnqual tvName (fsLit "forall")
 376 dot_tv_RDR    = mkUnqual tvName (fsLit ".")
 377
 378 eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR,
 379     ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName
 380 eq_RDR                  = nameRdrName eqName
 381 ge_RDR                  = nameRdrName geName
 382 ne_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "/=")
 383 le_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<=")
 384 lt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit "<")
 385 gt_RDR                  = varQual_RDR  gHC_CLASSES (fsLit ">")
 386 compare_RDR             = varQual_RDR  gHC_CLASSES (fsLit "compare")
 387 ltTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "LT")
 388 eqTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "EQ")
 389 gtTag_RDR               = dataQual_RDR gHC_ORDERING (fsLit "GT")
 390
 391 eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR
 392     :: RdrName
 393 eqClass_RDR             = nameRdrName eqClassName
 394 numClass_RDR            = nameRdrName numClassName
 395 ordClass_RDR            = nameRdrName ordClassName
 396 enumClass_RDR           = nameRdrName enumClassName
 397 monadClass_RDR          = nameRdrName monadClassName
 398
 399 map_RDR, append_RDR :: RdrName
 400 map_RDR                 = varQual_RDR gHC_BASE (fsLit "map")
 401 append_RDR              = varQual_RDR gHC_BASE (fsLit "++")
 402
 403 foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName
 404 foldr_RDR               = nameRdrName foldrName
 405 build_RDR               = nameRdrName buildName
 406 returnM_RDR             = nameRdrName returnMName
 407 bindM_RDR               = nameRdrName bindMName
 408 failM_RDR               = nameRdrName failMName
 409
 410 left_RDR, right_RDR :: RdrName
 411 left_RDR                = nameRdrName leftDataConName
 412 right_RDR               = nameRdrName rightDataConName
 413
 414 fromEnum_RDR, toEnum_RDR :: RdrName
 415 fromEnum_RDR            = varQual_RDR gHC_ENUM (fsLit "fromEnum")
 416 toEnum_RDR              = varQual_RDR gHC_ENUM (fsLit "toEnum")
 417
 418 enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName
 419 enumFrom_RDR            = nameRdrName enumFromName
 420 enumFromTo_RDR          = nameRdrName enumFromToName
 421 enumFromThen_RDR        = nameRdrName enumFromThenName
 422 enumFromThenTo_RDR      = nameRdrName enumFromThenToName
 423
 424 ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName
 425 ratioDataCon_RDR        = nameRdrName ratioDataConName
 426 plusInteger_RDR         = nameRdrName plusIntegerName
 427 timesInteger_RDR        = nameRdrName timesIntegerName
 428
 429 ioDataCon_RDR :: RdrName
 430 ioDataCon_RDR           = nameRdrName ioDataConName
 431
 432 eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR,
 433     unpackCStringUtf8_RDR :: RdrName
 434 eqString_RDR            = nameRdrName eqStringName
 435 unpackCString_RDR       = nameRdrName unpackCStringName
 436 unpackCStringFoldr_RDR  = nameRdrName unpackCStringFoldrName
 437 unpackCStringUtf8_RDR   = nameRdrName unpackCStringUtf8Name
 438
 439 newStablePtr_RDR, wordDataCon_RDR :: RdrName
 440 newStablePtr_RDR        = nameRdrName newStablePtrName
 441 wordDataCon_RDR         = dataQual_RDR gHC_WORD (fsLit "W#")
 442
 443 bindIO_RDR, returnIO_RDR :: RdrName
 444 bindIO_RDR              = nameRdrName bindIOName
 445 returnIO_RDR            = nameRdrName returnIOName
 446
 447 fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName
 448 fromInteger_RDR         = nameRdrName fromIntegerName
 449 fromRational_RDR        = nameRdrName fromRationalName
 450 minus_RDR               = nameRdrName minusName
 451 times_RDR               = varQual_RDR  gHC_NUM (fsLit "*")
 452 plus_RDR                = varQual_RDR gHC_NUM (fsLit "+")
 453
 454 fromString_RDR :: RdrName
 455 fromString_RDR          = nameRdrName fromStringName
 456
 457 compose_RDR :: RdrName
 458 compose_RDR             = varQual_RDR gHC_BASE (fsLit ".")
 459
 460 not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR,
 461     and_RDR, range_RDR, inRange_RDR, index_RDR,
 462     unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName
 463 and_RDR                 = varQual_RDR gHC_CLASSES (fsLit "&&")
 464 not_RDR                 = varQual_RDR gHC_CLASSES (fsLit "not")
 465 getTag_RDR              = varQual_RDR gHC_BASE (fsLit "getTag")
 466 succ_RDR                = varQual_RDR gHC_ENUM (fsLit "succ")
 467 pred_RDR                = varQual_RDR gHC_ENUM (fsLit "pred")
 468 minBound_RDR            = varQual_RDR gHC_ENUM (fsLit "minBound")
 469 maxBound_RDR            = varQual_RDR gHC_ENUM (fsLit "maxBound")
 470 range_RDR               = varQual_RDR gHC_ARR (fsLit "range")
 471 inRange_RDR             = varQual_RDR gHC_ARR (fsLit "inRange")
 472 index_RDR               = varQual_RDR gHC_ARR (fsLit "index")
 473 unsafeIndex_RDR         = varQual_RDR gHC_ARR (fsLit "unsafeIndex")
 474 unsafeRangeSize_RDR     = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize")
 475
 476 readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR,
 477     readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName
 478 readList_RDR            = varQual_RDR gHC_READ (fsLit "readList")
 479 readListDefault_RDR     = varQual_RDR gHC_READ (fsLit "readListDefault")
 480 readListPrec_RDR        = varQual_RDR gHC_READ (fsLit "readListPrec")
 481 readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault")
 482 readPrec_RDR            = varQual_RDR gHC_READ (fsLit "readPrec")
 483 parens_RDR              = varQual_RDR gHC_READ (fsLit "parens")
 484 choose_RDR              = varQual_RDR gHC_READ (fsLit "choose")
 485 lexP_RDR                = varQual_RDR gHC_READ (fsLit "lexP")
 486
 487 punc_RDR, ident_RDR, symbol_RDR :: RdrName
 488 punc_RDR                = dataQual_RDR lEX (fsLit "Punc")
 489 ident_RDR               = dataQual_RDR lEX (fsLit "Ident")
 490 symbol_RDR              = dataQual_RDR lEX (fsLit "Symbol")
 491
 492 step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName
 493 step_RDR                = varQual_RDR  rEAD_PREC (fsLit "step")
 494 alt_RDR                 = varQual_RDR  rEAD_PREC (fsLit "+++")
 495 reset_RDR               = varQual_RDR  rEAD_PREC (fsLit "reset")
 496 prec_RDR                = varQual_RDR  rEAD_PREC (fsLit "prec")
 497
 498 showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR,
 499     showSpace_RDR, showParen_RDR :: RdrName
 500 showList_RDR            = varQual_RDR gHC_SHOW (fsLit "showList")
 501 showList___RDR          = varQual_RDR gHC_SHOW (fsLit "showList__")
 502 showsPrec_RDR           = varQual_RDR gHC_SHOW (fsLit "showsPrec")
 503 showString_RDR          = varQual_RDR gHC_SHOW (fsLit "showString")
 504 showSpace_RDR           = varQual_RDR gHC_SHOW (fsLit "showSpace")
 505 showParen_RDR           = varQual_RDR gHC_SHOW (fsLit "showParen")
 506
 507 typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName
 508 typeOf_RDR     = varQual_RDR tYPEABLE (fsLit "typeOf")
 509 mkTypeRep_RDR  = varQual_RDR tYPEABLE (fsLit "mkTyConApp")
 510 mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon")
 511
 512 undefined_RDR :: RdrName
 513 undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined")
 514
 515 crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName
 516 crossDataCon_RDR   = dataQual_RDR gHC_GENERICS (fsLit ":*:")
 517 inlDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inl")
 518 inrDataCon_RDR     = dataQual_RDR gHC_GENERICS (fsLit "Inr")
 519 genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit")
 520
 521 fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName
 522 fmap_RDR                = varQual_RDR gHC_BASE (fsLit "fmap")
 523 pure_RDR                = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure")
 524 ap_RDR                  = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>")
 525 foldable_foldr_RDR      = varQual_RDR dATA_FOLDABLE       (fsLit "foldr")
 526 traverse_RDR            = varQual_RDR dATA_TRAVERSABLE    (fsLit "traverse")
 527
 528 ----------------------
 529 varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR
 530     :: Module -> FastString -> RdrName
 531 varQual_RDR  mod str = mkOrig mod (mkOccNameFS varName str)
 532 tcQual_RDR   mod str = mkOrig mod (mkOccNameFS tcName str)
 533 clsQual_RDR  mod str = mkOrig mod (mkOccNameFS clsName str)
 534 dataQual_RDR mod str = mkOrig mod (mkOccNameFS dataName str)
 535 \end{code}
 536
 537 %************************************************************************
 538 %*                                                                      *
 539 \subsection{Known-key names}
 540 %*                                                                      *
 541 %************************************************************************
 542
 543 Many of these Names are not really "built in", but some parts of the
 544 compiler (notably the deriving mechanism) need to mention their names,
 545 and it's convenient to write them all down in one place.
 546
 547 --MetaHaskell Extension  add the constrs and the lower case case
 548 -- guys as well (perhaps) e.g. see  trueDataConName     below
 549
 550
 551 \begin{code}
 552 wildCardName :: Name
 553 wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
 554
 555 runMainIOName :: Name
 556 runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
 557
 558 orderingTyConName :: Name
 559 orderingTyConName = tcQual   gHC_ORDERING (fsLit "Ordering") orderingTyConKey
 560
 561 eitherTyConName, leftDataConName, rightDataConName :: Name
 562 eitherTyConName   = tcQual  dATA_EITHER (fsLit "Either") eitherTyConKey
 563 leftDataConName   = conName dATA_EITHER (fsLit "Left")   leftDataConKey
 564 rightDataConName  = conName dATA_EITHER (fsLit "Right")  rightDataConKey
 565
 566 -- Generics
 567 crossTyConName, plusTyConName, genUnitTyConName :: Name
 568 crossTyConName     = tcQual   gHC_GENERICS (fsLit ":*:") crossTyConKey
 569 plusTyConName      = tcQual   gHC_GENERICS (fsLit ":+:") plusTyConKey
 570 genUnitTyConName   = tcQual   gHC_GENERICS (fsLit "Unit") genUnitTyConKey
 571
 572 -- Base strings Strings
 573 unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName,
 574     unpackCStringUtf8Name, eqStringName, stringTyConName :: Name
 575 unpackCStringName       = varQual gHC_BASE (fsLit "unpackCString#") unpackCStringIdKey
 576 unpackCStringAppendName = varQual gHC_BASE (fsLit "unpackAppendCString#") unpackCStringAppendIdKey
 577 unpackCStringFoldrName  = varQual gHC_BASE (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey
 578 unpackCStringUtf8Name   = varQual gHC_BASE (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey
 579 eqStringName            = varQual gHC_BASE (fsLit "eqString")  eqStringIdKey
 580 stringTyConName         = tcQual  gHC_BASE (fsLit "String") stringTyConKey
 581
 582 -- The 'inline' function
 583 inlineIdName :: Name
 584 inlineIdName            = varQual gHC_MAGIC (fsLit "inline") inlineIdKey
 585
 586 -- Base classes (Eq, Ord, Functor)
 587 eqClassName, eqName, ordClassName, geName, functorClassName :: Name
 588 eqClassName       = clsQual  gHC_CLASSES (fsLit "Eq")      eqClassKey
 589 eqName            = methName gHC_CLASSES (fsLit "==")      eqClassOpKey
 590 ordClassName      = clsQual  gHC_CLASSES (fsLit "Ord")     ordClassKey
 591 geName            = methName gHC_CLASSES (fsLit ">=")      geClassOpKey
 592 functorClassName  = clsQual  gHC_BASE (fsLit "Functor") functorClassKey
 593
 594 -- Class Monad
 595 monadClassName, thenMName, bindMName, returnMName, failMName :: Name
 596 monadClassName     = clsQual  gHC_BASE (fsLit "Monad")  monadClassKey
 597 thenMName          = methName gHC_BASE (fsLit ">>")     thenMClassOpKey
 598 bindMName          = methName gHC_BASE (fsLit ">>=")    bindMClassOpKey
 599 returnMName        = methName gHC_BASE (fsLit "return") returnMClassOpKey
 600 failMName          = methName gHC_BASE (fsLit "fail")   failMClassOpKey
 601
 602 -- Classes (Applicative, Foldable, Traversable)
 603 applicativeClassName, foldableClassName, traversableClassName :: Name
 604 applicativeClassName  = clsQual  cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey
 605 foldableClassName     = clsQual  dATA_FOLDABLE       (fsLit "Foldable")    foldableClassKey
 606 traversableClassName  = clsQual  dATA_TRAVERSABLE    (fsLit "Traversable") traversableClassKey
 607
 608 -- Functions for GHC extensions
 609 groupWithName :: Name
 610 groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey
 611
 612 -- Random PrelBase functions
 613 fromStringName, otherwiseIdName, foldrName, buildName, augmentName,
 614     mapName, appendName, assertName,
 615     breakpointName, breakpointCondName, breakpointAutoName,
 616     dollarName, opaqueTyConName :: Name
 617 fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey
 618 otherwiseIdName   = varQual gHC_BASE (fsLit "otherwise")  otherwiseIdKey
 619 foldrName         = varQual gHC_BASE (fsLit "foldr")      foldrIdKey
 620 buildName         = varQual gHC_BASE (fsLit "build")      buildIdKey
 621 augmentName       = varQual gHC_BASE (fsLit "augment")    augmentIdKey
 622 mapName           = varQual gHC_BASE (fsLit "map")        mapIdKey
 623 appendName        = varQual gHC_BASE (fsLit "++")         appendIdKey
 624 dollarName        = varQual gHC_BASE (fsLit "$")          dollarIdKey
 625 assertName        = varQual gHC_BASE (fsLit "assert")     assertIdKey
 626 breakpointName    = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey
 627 breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey
 628 breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey
 629 opaqueTyConName   = tcQual  gHC_BASE (fsLit "Opaque")   opaqueTyConKey
 630
 631 breakpointJumpName :: Name
 632 breakpointJumpName
 633     = mkInternalName
 634         breakpointJumpIdKey
 635         (mkOccNameFS varName (fsLit "breakpointJump"))
 636         noSrcSpan
 637 breakpointCondJumpName :: Name
 638 breakpointCondJumpName
 639     = mkInternalName
 640         breakpointCondJumpIdKey
 641         (mkOccNameFS varName (fsLit "breakpointCondJump"))
 642         noSrcSpan
 643 breakpointAutoJumpName :: Name
 644 breakpointAutoJumpName
 645     = mkInternalName
 646         breakpointAutoJumpIdKey
 647         (mkOccNameFS varName (fsLit "breakpointAutoJump"))
 648         noSrcSpan
 649
 650 -- PrelTup
 651 fstName, sndName :: Name
 652 fstName           = varQual dATA_TUPLE (fsLit "fst") fstIdKey
 653 sndName           = varQual dATA_TUPLE (fsLit "snd") sndIdKey
 654
 655 -- Module GHC.Num
 656 numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
 657     timesIntegerName,
 658     integerTyConName, smallIntegerName :: Name
 659 numClassName      = clsQual  gHC_NUM (fsLit "Num") numClassKey
 660 fromIntegerName   = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey
 661 minusName         = methName gHC_NUM (fsLit "-") minusClassOpKey
 662 negateName        = methName gHC_NUM (fsLit "negate") negateClassOpKey
 663 plusIntegerName   = varQual  gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey
 664 timesIntegerName  = varQual  gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey
 665 integerTyConName  = tcQual   gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
 666 smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
 667
 668 -- GHC.Real types and classes
 669 rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
 670     integralClassName, realFracClassName, fractionalClassName,
 671     fromRationalName, toIntegerName, toRationalName, fromIntegralName,
 672     realToFracName :: Name
 673 rationalTyConName   = tcQual  gHC_REAL (fsLit "Rational") rationalTyConKey
 674 ratioTyConName      = tcQual  gHC_REAL (fsLit "Ratio") ratioTyConKey
 675 ratioDataConName    = conName gHC_REAL (fsLit ":%") ratioDataConKey
 676 realClassName       = clsQual gHC_REAL (fsLit "Real") realClassKey
 677 integralClassName   = clsQual gHC_REAL (fsLit "Integral") integralClassKey
 678 realFracClassName   = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey
 679 fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey
 680 fromRationalName    = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey
 681 toIntegerName       = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey
 682 toRationalName      = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey
 683 fromIntegralName    = varQual  gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey
 684 realToFracName      = varQual  gHC_REAL (fsLit "realToFrac") realToFracIdKey
 685
 686 -- PrelFloat classes
 687 floatingClassName, realFloatClassName :: Name
 688 floatingClassName  = clsQual  gHC_FLOAT (fsLit "Floating") floatingClassKey
 689 realFloatClassName = clsQual  gHC_FLOAT (fsLit "RealFloat") realFloatClassKey
 690
 691 -- Class Ix
 692 ixClassName :: Name
 693 ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey
 694
 695 -- Class Typeable
 696 typeableClassName, typeable1ClassName, typeable2ClassName,
 697     typeable3ClassName, typeable4ClassName, typeable5ClassName,
 698     typeable6ClassName, typeable7ClassName :: Name
 699 typeableClassName  = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey
 700 typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey
 701 typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey
 702 typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey
 703 typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey
 704 typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey
 705 typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey
 706 typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey
 707
 708 typeableClassNames :: [Name]
 709 typeableClassNames =    [ typeableClassName, typeable1ClassName, typeable2ClassName
 710                         , typeable3ClassName, typeable4ClassName, typeable5ClassName
 711                         , typeable6ClassName, typeable7ClassName ]
 712
 713 -- Class Data
 714 dataClassName :: Name
 715 dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey
 716
 717 -- Error module
 718 assertErrorName    :: Name
 719 assertErrorName   = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey
 720
 721 -- Enum module (Enum, Bounded)
 722 enumClassName, enumFromName, enumFromToName, enumFromThenName,
 723     enumFromThenToName, boundedClassName :: Name
 724 enumClassName      = clsQual gHC_ENUM (fsLit "Enum") enumClassKey
 725 enumFromName       = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey
 726 enumFromToName     = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey
 727 enumFromThenName   = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey
 728 enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey
 729 boundedClassName   = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey
 730
 731 -- List functions
 732 concatName, filterName, zipName :: Name
 733 concatName        = varQual gHC_LIST (fsLit "concat") concatIdKey
 734 filterName        = varQual gHC_LIST (fsLit "filter") filterIdKey
 735 zipName           = varQual gHC_LIST (fsLit "zip") zipIdKey
 736
 737 -- Class Show
 738 showClassName :: Name
 739 showClassName     = clsQual gHC_SHOW (fsLit "Show")       showClassKey
 740
 741 -- Class Read
 742 readClassName :: Name
 743 readClassName      = clsQual gHC_READ (fsLit "Read") readClassKey
 744
 745 -- parallel array types and functions
 746 enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
 747     singletonPName, replicatePName, mapPName, filterPName,
 748     zipPName, crossMapPName, indexPName, toPName,
 749     emptyPName, appPName :: Name
 750 enumFromToPName    = varQual gHC_PARR (fsLit "enumFromToP") enumFromToPIdKey
 751 enumFromThenToPName= varQual gHC_PARR (fsLit "enumFromThenToP") enumFromThenToPIdKey
 752 nullPName         = varQual gHC_PARR (fsLit "nullP")             nullPIdKey
 753 lengthPName       = varQual gHC_PARR (fsLit "lengthP")           lengthPIdKey
 754 singletonPName    = varQual gHC_PARR (fsLit "singletonP")         singletonPIdKey
 755 replicatePName    = varQual gHC_PARR (fsLit "replicateP")        replicatePIdKey
 756 mapPName          = varQual gHC_PARR (fsLit "mapP")              mapPIdKey
 757 filterPName       = varQual gHC_PARR (fsLit "filterP")           filterPIdKey
 758 zipPName          = varQual gHC_PARR (fsLit "zipP")              zipPIdKey
 759 crossMapPName     = varQual gHC_PARR (fsLit "crossMapP")         crossMapPIdKey
 760 indexPName        = varQual gHC_PARR (fsLit "!:")                indexPIdKey
 761 toPName           = varQual gHC_PARR (fsLit "toP")               toPIdKey
 762 emptyPName        = varQual gHC_PARR (fsLit "emptyP")            emptyPIdKey
 763 appPName          = varQual gHC_PARR (fsLit "+:+")               appPIdKey
 764
 765 -- code type things
 766 hetmet_brak_name, hetmet_esc_name, hetmet_csp_name :: Name
 767 hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name, hetmet_guest_char_literal_name :: Name
 768 hetmet_brak_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_brak") hetmet_brak_key
 769 hetmet_esc_name  = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_esc")  hetmet_esc_key
 770 hetmet_csp_name  = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_csp") hetmet_csp_key
 771 hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_guest_integer_literal") hetmet_guest_integer_literal_key
 772 hetmet_guest_string_literal_name  = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_guest_string_literal")  hetmet_guest_string_literal_key
 773 hetmet_guest_char_literal_name    = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_guest_char_literal")    hetmet_guest_char_literal_key
 774
 775 -- IO things
 776 ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
 777     failIOName :: Name
 778 ioTyConName       = tcQual  gHC_TYPES (fsLit "IO") ioTyConKey
 779 ioDataConName     = conName gHC_TYPES (fsLit "IO") ioDataConKey
 780 thenIOName        = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey
 781 bindIOName        = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey
 782 returnIOName      = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey
 783 failIOName        = varQual gHC_IO (fsLit "failIO") failIOIdKey
 784
 785 -- IO things
 786 printName :: Name
 787 printName         = varQual sYSTEM_IO (fsLit "print") printIdKey
 788
 789 -- Int, Word, and Addr things
 790 int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name
 791 int8TyConName     = tcQual gHC_INT  (fsLit "Int8") int8TyConKey
 792 int16TyConName    = tcQual gHC_INT  (fsLit "Int16") int16TyConKey
 793 int32TyConName    = tcQual gHC_INT  (fsLit "Int32") int32TyConKey
 794 int64TyConName    = tcQual gHC_INT  (fsLit "Int64") int64TyConKey
 795
 796 -- Word module
 797 word8TyConName, word16TyConName, word32TyConName, word64TyConName,
 798     wordTyConName, wordDataConName :: Name
 799 word8TyConName    = tcQual  gHC_WORD (fsLit "Word8")  word8TyConKey
 800 word16TyConName   = tcQual  gHC_WORD (fsLit "Word16") word16TyConKey
 801 word32TyConName   = tcQual  gHC_WORD (fsLit "Word32") word32TyConKey
 802 word64TyConName   = tcQual  gHC_WORD (fsLit "Word64") word64TyConKey
 803 wordTyConName     = tcQual  gHC_WORD (fsLit "Word")   wordTyConKey
 804 wordDataConName   = conName gHC_WORD (fsLit "W#") wordDataConKey
 805
 806 -- PrelPtr module
 807 ptrTyConName, funPtrTyConName :: Name
 808 ptrTyConName      = tcQual   gHC_PTR (fsLit "Ptr") ptrTyConKey
 809 funPtrTyConName   = tcQual   gHC_PTR (fsLit "FunPtr") funPtrTyConKey
 810
 811 -- Foreign objects and weak pointers
 812 stablePtrTyConName, newStablePtrName :: Name
 813 stablePtrTyConName    = tcQual   gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey
 814 newStablePtrName      = varQual  gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey
 815
 816 -- PrelST module
 817 runSTRepName :: Name
 818 runSTRepName       = varQual gHC_ST  (fsLit "runSTRep") runSTRepIdKey
 819
 820 -- Recursive-do notation
 821 monadFixClassName, mfixName :: Name
 822 monadFixClassName  = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey
 823 mfixName           = methName mONAD_FIX (fsLit "mfix") mfixIdKey
 824
 825 -- Arrow notation
 826 arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name
 827 arrAName           = varQual aRROW (fsLit "arr")          arrAIdKey
 828 composeAName       = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey
 829 firstAName         = varQual aRROW (fsLit "first") firstAIdKey
 830 appAName           = varQual aRROW (fsLit "app")          appAIdKey
 831 choiceAName        = varQual aRROW (fsLit "|||")          choiceAIdKey
 832 loopAName          = varQual aRROW (fsLit "loop")  loopAIdKey
 833
 834 -- Annotation type checking
 835 toAnnotationWrapperName :: Name
 836 toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey
 837
 838 -- Other classes, needed for type defaulting
 839 monadPlusClassName, randomClassName, randomGenClassName,
 840     isStringClassName :: Name
 841 monadPlusClassName  = clsQual mONAD (fsLit "MonadPlus")  monadPlusClassKey
 842 randomClassName     = clsQual rANDOM (fsLit "Random")    randomClassKey
 843 randomGenClassName  = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey
 844 isStringClassName   = clsQual dATA_STRING (fsLit "IsString") isStringClassKey
 845
 846 -- dotnet interop
 847 objectTyConName :: Name
 848 objectTyConName     = tcQual   dOTNET (fsLit "Object") objectTyConKey
 849         -- objectTyConName was "wTcQual", but that's gone now, and
 850         -- I can't see why it was wired in anyway...
 851 unmarshalObjectName, marshalObjectName, marshalStringName,
 852     unmarshalStringName, checkDotnetResName :: Name
 853 unmarshalObjectName = varQual  dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey
 854 marshalObjectName   = varQual  dOTNET (fsLit "marshalObject") marshalObjectIdKey
 855 marshalStringName   = varQual  dOTNET (fsLit "marshalString") marshalStringIdKey
 856 unmarshalStringName = varQual  dOTNET (fsLit "unmarshalString") unmarshalStringIdKey
 857 checkDotnetResName  = varQual  dOTNET (fsLit "checkResult")     checkDotnetResNameIdKey
 858 \end{code}
 859
 860 %************************************************************************
 861 %*                                                                      *
 862 \subsection{Local helpers}
 863 %*                                                                      *
 864 %************************************************************************
 865
 866 All these are original names; hence mkOrig
 867
 868 \begin{code}
 869 varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name
 870 varQual  = mk_known_key_name varName
 871 tcQual   = mk_known_key_name tcName
 872 clsQual  = mk_known_key_name clsName
 873
 874 mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name
 875 mk_known_key_name space modu str unique
 876   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan
 877
 878 conName :: Module -> FastString -> Unique -> Name
 879 conName modu occ unique
 880   = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan
 881
 882 methName :: Module -> FastString -> Unique -> Name
 883 methName modu occ unique
 884   = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan
 885 \end{code}
 886
 887 %************************************************************************
 888 %*                                                                      *
 889 \subsubsection[Uniques-prelude-Classes]{@Uniques@ for wired-in @Classes@}
 890 %*                                                                      *
 891 %************************************************************************
 892 --MetaHaskell extension hand allocate keys here
 893
 894 \begin{code}
 895 boundedClassKey, enumClassKey, eqClassKey, floatingClassKey,
 896     fractionalClassKey, integralClassKey, monadClassKey, dataClassKey,
 897     functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey,
 898     realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique
 899 boundedClassKey         = mkPreludeClassUnique 1
 900 enumClassKey            = mkPreludeClassUnique 2
 901 eqClassKey              = mkPreludeClassUnique 3
 902 floatingClassKey        = mkPreludeClassUnique 5
 903 fractionalClassKey      = mkPreludeClassUnique 6
 904 integralClassKey        = mkPreludeClassUnique 7
 905 monadClassKey           = mkPreludeClassUnique 8
 906 dataClassKey            = mkPreludeClassUnique 9
 907 functorClassKey         = mkPreludeClassUnique 10
 908 numClassKey             = mkPreludeClassUnique 11
 909 ordClassKey             = mkPreludeClassUnique 12
 910 readClassKey            = mkPreludeClassUnique 13
 911 realClassKey            = mkPreludeClassUnique 14
 912 realFloatClassKey       = mkPreludeClassUnique 15
 913 realFracClassKey        = mkPreludeClassUnique 16
 914 showClassKey            = mkPreludeClassUnique 17
 915 ixClassKey              = mkPreludeClassUnique 18
 916
 917 typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey,
 918     typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey
 919     :: Unique
 920 typeableClassKey        = mkPreludeClassUnique 20
 921 typeable1ClassKey       = mkPreludeClassUnique 21
 922 typeable2ClassKey       = mkPreludeClassUnique 22
 923 typeable3ClassKey       = mkPreludeClassUnique 23
 924 typeable4ClassKey       = mkPreludeClassUnique 24
 925 typeable5ClassKey       = mkPreludeClassUnique 25
 926 typeable6ClassKey       = mkPreludeClassUnique 26
 927 typeable7ClassKey       = mkPreludeClassUnique 27
 928
 929 monadFixClassKey :: Unique
 930 monadFixClassKey        = mkPreludeClassUnique 28
 931
 932 monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
 933 monadPlusClassKey       = mkPreludeClassUnique 30
 934 randomClassKey          = mkPreludeClassUnique 31
 935 randomGenClassKey       = mkPreludeClassUnique 32
 936
 937 isStringClassKey :: Unique
 938 isStringClassKey        = mkPreludeClassUnique 33
 939
 940 applicativeClassKey, foldableClassKey, traversableClassKey :: Unique
 941 applicativeClassKey     = mkPreludeClassUnique 34
 942 foldableClassKey        = mkPreludeClassUnique 35
 943 traversableClassKey     = mkPreludeClassUnique 36
 944 \end{code}
 945
 946 %************************************************************************
 947 %*                                                                      *
 948 \subsubsection[Uniques-prelude-TyCons]{@Uniques@ for wired-in @TyCons@}
 949 %*                                                                      *
 950 %************************************************************************
 951
 952 \begin{code}
 953 addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey,
 954     charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey,
 955     floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey,
 956     intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey,
 957     int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey,
 958     listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey,
 959     mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey,
 960     orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey,
 961     realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey,
 962     anyTyConKey :: Unique
 963 addrPrimTyConKey                        = mkPreludeTyConUnique  1
 964 arrayPrimTyConKey                       = mkPreludeTyConUnique  3
 965 boolTyConKey                            = mkPreludeTyConUnique  4
 966 byteArrayPrimTyConKey                   = mkPreludeTyConUnique  5
 967 charPrimTyConKey                        = mkPreludeTyConUnique  7
 968 charTyConKey                            = mkPreludeTyConUnique  8
 969 doublePrimTyConKey                      = mkPreludeTyConUnique  9
 970 doubleTyConKey                          = mkPreludeTyConUnique 10
 971 floatPrimTyConKey                       = mkPreludeTyConUnique 11
 972 floatTyConKey                           = mkPreludeTyConUnique 12
 973 funTyConKey                             = mkPreludeTyConUnique 13
 974 intPrimTyConKey                         = mkPreludeTyConUnique 14
 975 intTyConKey                             = mkPreludeTyConUnique 15
 976 int8TyConKey                            = mkPreludeTyConUnique 16
 977 int16TyConKey                           = mkPreludeTyConUnique 17
 978 int32PrimTyConKey                       = mkPreludeTyConUnique 18
 979 int32TyConKey                           = mkPreludeTyConUnique 19
 980 int64PrimTyConKey                       = mkPreludeTyConUnique 20
 981 int64TyConKey                           = mkPreludeTyConUnique 21
 982 integerTyConKey                         = mkPreludeTyConUnique 22
 983 listTyConKey                            = mkPreludeTyConUnique 23
 984 foreignObjPrimTyConKey                  = mkPreludeTyConUnique 24
 985 weakPrimTyConKey                        = mkPreludeTyConUnique 27
 986 mutableArrayPrimTyConKey                = mkPreludeTyConUnique 28
 987 mutableByteArrayPrimTyConKey            = mkPreludeTyConUnique 29
 988 orderingTyConKey                        = mkPreludeTyConUnique 30
 989 mVarPrimTyConKey                        = mkPreludeTyConUnique 31
 990 ratioTyConKey                           = mkPreludeTyConUnique 32
 991 rationalTyConKey                        = mkPreludeTyConUnique 33
 992 realWorldTyConKey                       = mkPreludeTyConUnique 34
 993 stablePtrPrimTyConKey                   = mkPreludeTyConUnique 35
 994 stablePtrTyConKey                       = mkPreludeTyConUnique 36
 995 anyTyConKey                             = mkPreludeTyConUnique 37
 996
 997 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey,
 998     mutVarPrimTyConKey, ioTyConKey,
 999     wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey,
1000     word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey,
1001     liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey,
1002     typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey,
1003     funPtrTyConKey, tVarPrimTyConKey :: Unique
1004 statePrimTyConKey                       = mkPreludeTyConUnique 50
1005 stableNamePrimTyConKey                  = mkPreludeTyConUnique 51
1006 stableNameTyConKey                      = mkPreludeTyConUnique 52
1007 mutVarPrimTyConKey                      = mkPreludeTyConUnique 55
1008 ioTyConKey                              = mkPreludeTyConUnique 56
1009 wordPrimTyConKey                        = mkPreludeTyConUnique 58
1010 wordTyConKey                            = mkPreludeTyConUnique 59
1011 word8TyConKey                           = mkPreludeTyConUnique 60
1012 word16TyConKey                          = mkPreludeTyConUnique 61
1013 word32PrimTyConKey                      = mkPreludeTyConUnique 62
1014 word32TyConKey                          = mkPreludeTyConUnique 63
1015 word64PrimTyConKey                      = mkPreludeTyConUnique 64
1016 word64TyConKey                          = mkPreludeTyConUnique 65
1017 liftedConKey                            = mkPreludeTyConUnique 66
1018 unliftedConKey                          = mkPreludeTyConUnique 67
1019 anyBoxConKey                            = mkPreludeTyConUnique 68
1020 kindConKey                              = mkPreludeTyConUnique 69
1021 boxityConKey                            = mkPreludeTyConUnique 70
1022 typeConKey                              = mkPreludeTyConUnique 71
1023 threadIdPrimTyConKey                    = mkPreludeTyConUnique 72
1024 bcoPrimTyConKey                         = mkPreludeTyConUnique 73
1025 ptrTyConKey                             = mkPreludeTyConUnique 74
1026 funPtrTyConKey                          = mkPreludeTyConUnique 75
1027 tVarPrimTyConKey                        = mkPreludeTyConUnique 76
1028
1029 -- Generic Type Constructors
1030 crossTyConKey, plusTyConKey, genUnitTyConKey :: Unique
1031 crossTyConKey                           = mkPreludeTyConUnique 79
1032 plusTyConKey                            = mkPreludeTyConUnique 80
1033 genUnitTyConKey                         = mkPreludeTyConUnique 81
1034
1035 -- Parallel array type constructor
1036 parrTyConKey :: Unique
1037 parrTyConKey                            = mkPreludeTyConUnique 82
1038
1039 -- dotnet interop
1040 objectTyConKey :: Unique
1041 objectTyConKey                          = mkPreludeTyConUnique 83
1042
1043 eitherTyConKey :: Unique
1044 eitherTyConKey                          = mkPreludeTyConUnique 84
1045
1046 -- Super Kinds constructors
1047 tySuperKindTyConKey, coSuperKindTyConKey :: Unique
1048 tySuperKindTyConKey                    = mkPreludeTyConUnique 85
1049 coSuperKindTyConKey                    = mkPreludeTyConUnique 86
1050
1051 -- Kind constructors
1052 liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey,
1053     ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique
1054 liftedTypeKindTyConKey                  = mkPreludeTyConUnique 87
1055 openTypeKindTyConKey                    = mkPreludeTyConUnique 88
1056 unliftedTypeKindTyConKey                = mkPreludeTyConUnique 89
1057 ubxTupleKindTyConKey                    = mkPreludeTyConUnique 90
1058 argTypeKindTyConKey                     = mkPreludeTyConUnique 91
1059
1060 -- Coercion constructors
1061 symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey,
1062     rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey,
1063     csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey
1064     :: Unique
1065 symCoercionTyConKey                     = mkPreludeTyConUnique 93
1066 transCoercionTyConKey                   = mkPreludeTyConUnique 94
1067 leftCoercionTyConKey                    = mkPreludeTyConUnique 95
1068 rightCoercionTyConKey                   = mkPreludeTyConUnique 96
1069 instCoercionTyConKey                    = mkPreludeTyConUnique 97
1070 unsafeCoercionTyConKey                  = mkPreludeTyConUnique 98
1071 csel1CoercionTyConKey                   = mkPreludeTyConUnique 99
1072 csel2CoercionTyConKey                   = mkPreludeTyConUnique 100
1073 cselRCoercionTyConKey                   = mkPreludeTyConUnique 101
1074
1075 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey,
1076     opaqueTyConKey :: Unique
1077 unknownTyConKey                         = mkPreludeTyConUnique 129
1078 unknown1TyConKey                        = mkPreludeTyConUnique 130
1079 unknown2TyConKey                        = mkPreludeTyConUnique 131
1080 unknown3TyConKey                        = mkPreludeTyConUnique 132
1081 opaqueTyConKey                          = mkPreludeTyConUnique 133
1082
1083 stringTyConKey :: Unique
1084 stringTyConKey                          = mkPreludeTyConUnique 134
1085
1086 -- Heterogeneous Metaprogramming code type constructor
1087 hetMetCodeTypeTyConKey :: Unique
1088 hetMetCodeTypeTyConKey                  = mkPreludeTyConUnique 135
1089
1090 ---------------- Template Haskell -------------------
1091 --      USES TyConUniques 100-129
1092 -----------------------------------------------------
1093
1094 unitTyConKey :: Unique
1095 unitTyConKey = mkTupleTyConUnique Boxed 0
1096 \end{code}
1097
1098 %************************************************************************
1099 %*                                                                      *
1100 \subsubsection[Uniques-prelude-DataCons]{@Uniques@ for wired-in @DataCons@}
1101 %*                                                                      *
1102 %************************************************************************
1103
1104 \begin{code}
1105 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey,
1106     floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey,
1107     stableNameDataConKey, trueDataConKey, wordDataConKey,
1108     ioDataConKey, integerDataConKey :: Unique
1109 charDataConKey                          = mkPreludeDataConUnique  1
1110 consDataConKey                          = mkPreludeDataConUnique  2
1111 doubleDataConKey                        = mkPreludeDataConUnique  3
1112 falseDataConKey                         = mkPreludeDataConUnique  4
1113 floatDataConKey                         = mkPreludeDataConUnique  5
1114 intDataConKey                           = mkPreludeDataConUnique  6
1115 nilDataConKey                           = mkPreludeDataConUnique 11
1116 ratioDataConKey                         = mkPreludeDataConUnique 12
1117 stableNameDataConKey                    = mkPreludeDataConUnique 14
1118 trueDataConKey                          = mkPreludeDataConUnique 15
1119 wordDataConKey                          = mkPreludeDataConUnique 16
1120 ioDataConKey                            = mkPreludeDataConUnique 17
1121 integerDataConKey                       = mkPreludeDataConUnique 18
1122
1123 -- Generic data constructors
1124 crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique
1125 crossDataConKey                         = mkPreludeDataConUnique 20
1126 inlDataConKey                           = mkPreludeDataConUnique 21
1127 inrDataConKey                           = mkPreludeDataConUnique 22
1128 genUnitDataConKey                       = mkPreludeDataConUnique 23
1129
1130 -- Data constructor for parallel arrays
1131 parrDataConKey :: Unique
1132 parrDataConKey                          = mkPreludeDataConUnique 24
1133
1134 leftDataConKey, rightDataConKey :: Unique
1135 leftDataConKey                          = mkPreludeDataConUnique 25
1136 rightDataConKey                         = mkPreludeDataConUnique 26
1137
1138 -- Data constructor for Heterogeneous Metaprogramming code types
1139 hetMetCodeTypeDataConKey :: Unique
1140 hetMetCodeTypeDataConKey                        = mkPreludeDataConUnique 27
1141 \end{code}
1142
1143 %************************************************************************
1144 %*                                                                      *
1145 \subsubsection[Uniques-prelude-Ids]{@Uniques@ for wired-in @Ids@ (except @DataCons@)}
1146 %*                                                                      *
1147 %************************************************************************
1148
1149 \begin{code}
1150 absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey,
1151     foldlIdKey, foldrIdKey, recSelErrorIdKey,
1152     integerMinusOneIdKey, integerPlusOneIdKey,
1153     integerPlusTwoIdKey, integerZeroIdKey,
1154     int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey,
1155     noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
1156     runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
1157     realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
1158     traceIdKey, wildCardKey,
1159     unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
1160     unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
1161 wildCardKey                   = mkPreludeMiscIdUnique  0  -- See Note [WildCard]
1162 absentErrorIdKey              = mkPreludeMiscIdUnique  1
1163 augmentIdKey                  = mkPreludeMiscIdUnique  3
1164 appendIdKey                   = mkPreludeMiscIdUnique  4
1165 buildIdKey                    = mkPreludeMiscIdUnique  5
1166 errorIdKey                    = mkPreludeMiscIdUnique  6
1167 foldlIdKey                    = mkPreludeMiscIdUnique  7
1168 foldrIdKey                    = mkPreludeMiscIdUnique  8
1169 recSelErrorIdKey              = mkPreludeMiscIdUnique  9
1170 integerMinusOneIdKey          = mkPreludeMiscIdUnique 10
1171 integerPlusOneIdKey           = mkPreludeMiscIdUnique 11
1172 integerPlusTwoIdKey           = mkPreludeMiscIdUnique 12
1173 integerZeroIdKey              = mkPreludeMiscIdUnique 13
1174 int2IntegerIdKey              = mkPreludeMiscIdUnique 14
1175 seqIdKey                      = mkPreludeMiscIdUnique 15
1176 irrefutPatErrorIdKey          = mkPreludeMiscIdUnique 16
1177 eqStringIdKey                 = mkPreludeMiscIdUnique 17
1178 noMethodBindingErrorIdKey     = mkPreludeMiscIdUnique 18
1179 nonExhaustiveGuardsErrorIdKey = mkPreludeMiscIdUnique 19
1180 runtimeErrorIdKey             = mkPreludeMiscIdUnique 20
1181 parErrorIdKey                 = mkPreludeMiscIdUnique 21
1182 parIdKey                      = mkPreludeMiscIdUnique 22
1183 patErrorIdKey                 = mkPreludeMiscIdUnique 23
1184 realWorldPrimIdKey            = mkPreludeMiscIdUnique 24
1185 recConErrorIdKey              = mkPreludeMiscIdUnique 25
1186 recUpdErrorIdKey              = mkPreludeMiscIdUnique 26
1187 traceIdKey                    = mkPreludeMiscIdUnique 27
1188 unpackCStringUtf8IdKey        = mkPreludeMiscIdUnique 28
1189 unpackCStringAppendIdKey      = mkPreludeMiscIdUnique 29
1190 unpackCStringFoldrIdKey       = mkPreludeMiscIdUnique 30
1191 unpackCStringIdKey            = mkPreludeMiscIdUnique 31
1192
1193 unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey,
1194     returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey,
1195     smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey,
1196     printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey,
1197     fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique
1198 unsafeCoerceIdKey             = mkPreludeMiscIdUnique 32
1199 concatIdKey                   = mkPreludeMiscIdUnique 33
1200 filterIdKey                   = mkPreludeMiscIdUnique 34
1201 zipIdKey                      = mkPreludeMiscIdUnique 35
1202 bindIOIdKey                   = mkPreludeMiscIdUnique 36
1203 returnIOIdKey                 = mkPreludeMiscIdUnique 37
1204 deRefStablePtrIdKey           = mkPreludeMiscIdUnique 38
1205 newStablePtrIdKey             = mkPreludeMiscIdUnique 39
1206 smallIntegerIdKey             = mkPreludeMiscIdUnique 40
1207 plusIntegerIdKey              = mkPreludeMiscIdUnique 41
1208 timesIntegerIdKey             = mkPreludeMiscIdUnique 42
1209 printIdKey                    = mkPreludeMiscIdUnique 43
1210 failIOIdKey                   = mkPreludeMiscIdUnique 44
1211 nullAddrIdKey                 = mkPreludeMiscIdUnique 46
1212 voidArgIdKey                  = mkPreludeMiscIdUnique 47
1213 fstIdKey                      = mkPreludeMiscIdUnique 49
1214 sndIdKey                      = mkPreludeMiscIdUnique 50
1215 otherwiseIdKey                = mkPreludeMiscIdUnique 51
1216 assertIdKey                   = mkPreludeMiscIdUnique 53
1217 runSTRepIdKey                 = mkPreludeMiscIdUnique 54
1218
1219 rootMainKey, runMainKey :: Unique
1220 rootMainKey                   = mkPreludeMiscIdUnique 55
1221 runMainKey                    = mkPreludeMiscIdUnique 56
1222
1223 thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique
1224 thenIOIdKey                   = mkPreludeMiscIdUnique 59
1225 lazyIdKey                     = mkPreludeMiscIdUnique 60
1226 assertErrorIdKey              = mkPreludeMiscIdUnique 61
1227
1228 breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey,
1229     breakpointJumpIdKey, breakpointCondJumpIdKey,
1230     breakpointAutoJumpIdKey :: Unique
1231 breakpointIdKey               = mkPreludeMiscIdUnique 62
1232 breakpointCondIdKey           = mkPreludeMiscIdUnique 63
1233 breakpointAutoIdKey           = mkPreludeMiscIdUnique 64
1234 breakpointJumpIdKey           = mkPreludeMiscIdUnique 65
1235 breakpointCondJumpIdKey       = mkPreludeMiscIdUnique 66
1236 breakpointAutoJumpIdKey       = mkPreludeMiscIdUnique 67
1237
1238 inlineIdKey :: Unique
1239 inlineIdKey                   = mkPreludeMiscIdUnique 68
1240
1241 mapIdKey, groupWithIdKey, dollarIdKey :: Unique
1242 mapIdKey              = mkPreludeMiscIdUnique 69
1243 groupWithIdKey        = mkPreludeMiscIdUnique 70
1244 dollarIdKey           = mkPreludeMiscIdUnique 71
1245
1246 -- Parallel array functions
1247 singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey,
1248     filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey,
1249     enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique
1250 singletonPIdKey               = mkPreludeMiscIdUnique 79
1251 nullPIdKey                    = mkPreludeMiscIdUnique 80
1252 lengthPIdKey                  = mkPreludeMiscIdUnique 81
1253 replicatePIdKey               = mkPreludeMiscIdUnique 82
1254 mapPIdKey                     = mkPreludeMiscIdUnique 83
1255 filterPIdKey                  = mkPreludeMiscIdUnique 84
1256 zipPIdKey                     = mkPreludeMiscIdUnique 85
1257 crossMapPIdKey                = mkPreludeMiscIdUnique 86
1258 indexPIdKey                   = mkPreludeMiscIdUnique 87
1259 toPIdKey                      = mkPreludeMiscIdUnique 88
1260 enumFromToPIdKey              = mkPreludeMiscIdUnique 89
1261 enumFromThenToPIdKey          = mkPreludeMiscIdUnique 90
1262 emptyPIdKey                   = mkPreludeMiscIdUnique 91
1263 appPIdKey                     = mkPreludeMiscIdUnique 92
1264
1265 -- dotnet interop
1266 unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey,
1267     unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique
1268 unmarshalObjectIdKey          = mkPreludeMiscIdUnique 94
1269 marshalObjectIdKey            = mkPreludeMiscIdUnique 95
1270 marshalStringIdKey            = mkPreludeMiscIdUnique 96
1271 unmarshalStringIdKey          = mkPreludeMiscIdUnique 97
1272 checkDotnetResNameIdKey       = mkPreludeMiscIdUnique 98
1273
1274 \end{code}
1275
1276 Certain class operations from Prelude classes.  They get their own
1277 uniques so we can look them up easily when we want to conjure them up
1278 during type checking.
1279
1280 \begin{code}
1281         -- Just a place holder for  unbound variables  produced by the renamer:
1282 unboundKey :: Unique
1283 unboundKey                    = mkPreludeMiscIdUnique 101
1284
1285 fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey,
1286     enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey,
1287     enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey,
1288     failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey
1289     :: Unique
1290 fromIntegerClassOpKey         = mkPreludeMiscIdUnique 102
1291 minusClassOpKey               = mkPreludeMiscIdUnique 103
1292 fromRationalClassOpKey        = mkPreludeMiscIdUnique 104
1293 enumFromClassOpKey            = mkPreludeMiscIdUnique 105
1294 enumFromThenClassOpKey        = mkPreludeMiscIdUnique 106
1295 enumFromToClassOpKey          = mkPreludeMiscIdUnique 107
1296 enumFromThenToClassOpKey      = mkPreludeMiscIdUnique 108
1297 eqClassOpKey                  = mkPreludeMiscIdUnique 109
1298 geClassOpKey                  = mkPreludeMiscIdUnique 110
1299 negateClassOpKey              = mkPreludeMiscIdUnique 111
1300 failMClassOpKey               = mkPreludeMiscIdUnique 112
1301 bindMClassOpKey               = mkPreludeMiscIdUnique 113 -- (>>=)
1302 thenMClassOpKey               = mkPreludeMiscIdUnique 114 -- (>>)
1303 returnMClassOpKey             = mkPreludeMiscIdUnique 117
1304
1305 -- Recursive do notation
1306 mfixIdKey :: Unique
1307 mfixIdKey       = mkPreludeMiscIdUnique 118
1308
1309 -- Arrow notation
1310 arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey,
1311     loopAIdKey :: Unique
1312 arrAIdKey       = mkPreludeMiscIdUnique 119
1313 composeAIdKey   = mkPreludeMiscIdUnique 120 -- >>>
1314 firstAIdKey     = mkPreludeMiscIdUnique 121
1315 appAIdKey       = mkPreludeMiscIdUnique 122
1316 choiceAIdKey    = mkPreludeMiscIdUnique 123 --  |||
1317 loopAIdKey      = mkPreludeMiscIdUnique 124
1318
1319 fromStringClassOpKey :: Unique
1320 fromStringClassOpKey          = mkPreludeMiscIdUnique 125
1321
1322 -- Annotation type checking
1323 toAnnotationWrapperIdKey :: Unique
1324 toAnnotationWrapperIdKey      = mkPreludeMiscIdUnique 126
1325
1326 -- Conversion functions
1327 fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
1328 fromIntegralIdKey    = mkPreludeMiscIdUnique 127
1329 realToFracIdKey      = mkPreludeMiscIdUnique 128
1330 toIntegerClassOpKey  = mkPreludeMiscIdUnique 129
1331 toRationalClassOpKey = mkPreludeMiscIdUnique 130
1332
1333 -- code types
1334 hetmet_brak_key, hetmet_esc_key, hetmet_csp_key :: Unique
1335 hetmet_brak_key    = mkPreludeMiscIdUnique 131
1336 hetmet_esc_key     = mkPreludeMiscIdUnique 132
1337 hetmet_csp_key     = mkPreludeMiscIdUnique 133
1338 hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique
1339 hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 134
1340 hetmet_guest_string_literal_key  = mkPreludeMiscIdUnique 135
1341 hetmet_guest_char_literal_key    = mkPreludeMiscIdUnique 136
1342
1343 ---------------- Template Haskell -------------------
1344 --      USES IdUniques 200-399
1345 -----------------------------------------------------
1346 \end{code}
1347
1348
1349 %************************************************************************
1350 %*                                                                      *
1351 \subsection{Standard groups of types}
1352 %*                                                                      *
1353 %************************************************************************
1354
1355 \begin{code}
1356 numericTyKeys :: [Unique]
1357 numericTyKeys =
1358         [ wordTyConKey
1359         , intTyConKey
1360         , integerTyConKey
1361         , doubleTyConKey
1362         , floatTyConKey
1363         ]
1364
1365 kindKeys :: [Unique]
1366 kindKeys = [ liftedTypeKindTyConKey
1367            , openTypeKindTyConKey
1368            , unliftedTypeKindTyConKey
1369            , ubxTupleKindTyConKey
1370            , argTypeKindTyConKey ]
1371 \end{code}
1372
1373
1374 %************************************************************************
1375 %*                                                                      *
1376 \subsection[Class-std-groups]{Standard groups of Prelude classes}
1377 %*                                                                      *
1378 %************************************************************************
1379
1380 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
1381 even though every numeric class has these two as a superclass,
1382 because the list of ambiguous dictionaries hasn't been simplified.
1383
1384 \begin{code}
1385 numericClassKeys :: [Unique]
1386 numericClassKeys =
1387         [ numClassKey
1388         , realClassKey
1389         , integralClassKey
1390         ]
1391         ++ fractionalClassKeys
1392
1393 fractionalClassKeys :: [Unique]
1394 fractionalClassKeys =
1395         [ fractionalClassKey
1396         , floatingClassKey
1397         , realFracClassKey
1398         , realFloatClassKey
1399         ]
1400
1401         -- the strictness analyser needs to know about numeric types
1402         -- (see SaAbsInt.lhs)
1403 needsDataDeclCtxtClassKeys :: [Unique]
1404 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
1405         [ readClassKey
1406         ]
1407
1408 -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4),
1409 -- and are: "classes defined in the Prelude or a standard library"
1410 standardClassKeys :: [Unique]
1411 standardClassKeys = derivableClassKeys ++ numericClassKeys
1412                   ++ [randomClassKey, randomGenClassKey,
1413                       functorClassKey,
1414                       monadClassKey, monadPlusClassKey,
1415                       isStringClassKey,
1416                       applicativeClassKey, foldableClassKey, traversableClassKey
1417                      ]
1418 \end{code}
1419
1420 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
1421 (@TcDeriv@).
1422
1423 \begin{code}
1424 derivableClassKeys :: [Unique]
1425 derivableClassKeys
1426   = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey,
1427       boundedClassKey, showClassKey, readClassKey ]
1428 \end{code}
1429