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