ghc/compiler/prelude/PrelInfo.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[PrelInfo]{The @PrelInfo@ interface to the compiler's prelude knowledge}
   5
   6 \begin{code}
   7 module PrelInfo (
   8         module PrelNames,
   9         module MkId,
  10
  11         builtinNames,   -- Names of things whose *unique* must be known, but
  12                         -- that is all. If something is in here, you know that
  13                         -- if it's used at all then it's Name will be just as
  14                         -- it is here, unique and all.  Includes all the
  15
  16         derivingOccurrences,    -- For a given class C, this tells what other
  17         derivableClassKeys,     -- things are needed as a result of a
  18                                 -- deriving(C) clause
  19
  20
  21
  22         -- Primop RdrNames
  23         eqH_Char_RDR,   ltH_Char_RDR,   eqH_Word_RDR,  ltH_Word_RDR,
  24         eqH_Addr_RDR,   ltH_Addr_RDR,   eqH_Float_RDR, ltH_Float_RDR,
  25         eqH_Double_RDR, ltH_Double_RDR, eqH_Int_RDR,   ltH_Int_RDR,
  26         geH_RDR, leH_RDR, minusH_RDR, tagToEnumH_RDR,
  27
  28         -- Random other things
  29         maybeCharLikeCon, maybeIntLikeCon,
  30         needsDataDeclCtxtClassKeys, cCallishClassKeys, cCallishTyKeys,
  31         isNoDictClass, isNumericClass, isStandardClass, isCcallishClass,
  32         isCreturnableClass, numericTyKeys, fractionalClassKeys,
  33
  34     ) where
  35
  36 #include "HsVersions.h"
  37
  38 -- friends:
  39 import MkId             -- Ditto
  40 import PrelNames        -- Prelude module names
  41
  42 import PrimOp           ( PrimOp(..), allThePrimOps, primOpRdrName )
  43 import DataCon          ( DataCon, dataConId, dataConWrapId )
  44 import TysPrim          -- TYPES
  45 import TysWiredIn
  46
  47 -- others:
  48 import RdrName          ( RdrName )
  49 import Name             ( Name, mkKnownKeyGlobal, getName )
  50 import Class            ( Class, classKey )
  51 import TyCon            ( tyConDataConsIfAvailable, TyCon )
  52 import Type             ( funTyCon )
  53 import Bag
  54 import BasicTypes       ( Boxity(..) )
  55 import Unique           -- *Key stuff
  56 import UniqFM           ( UniqFM, listToUFM )
  57 import Util             ( isIn )
  58 \end{code}
  59
  60 %************************************************************************
  61 %*                                                                      *
  62 \subsection[builtinNameInfo]{Lookup built-in names}
  63 %*                                                                      *
  64 %************************************************************************
  65
  66 We have two ``builtin name funs,'' one to look up @TyCons@ and
  67 @Classes@, the other to look up values.
  68
  69 \begin{code}
  70 builtinNames :: Bag Name
  71 builtinNames
  72   = unionManyBags
  73         [       -- Wired in TyCons
  74           unionManyBags (map getTyConNames wired_in_tycons)
  75
  76                 -- Wired in Ids
  77         , listToBag (map getName wiredInIds)
  78
  79                 -- PrimOps
  80         , listToBag (map (getName . mkPrimOpId) allThePrimOps)
  81
  82                 -- Other names with magic keys
  83         , listToBag knownKeyNames
  84         ]
  85 \end{code}
  86
  87
  88 \begin{code}
  89 getTyConNames :: TyCon -> Bag Name
  90 getTyConNames tycon
  91     = getName tycon `consBag`
  92       unionManyBags (map get_data_con_names (tyConDataConsIfAvailable tycon))
  93         -- Synonyms return empty list of constructors
  94     where
  95       get_data_con_names dc = listToBag [getName (dataConId dc),        -- Worker
  96                                          getName (dataConWrapId dc)]    -- Wrapper
  97 \end{code}
  98
  99 We let a lot of "non-standard" values be visible, so that we can make
 100 sense of them in interface pragmas. It's cool, though they all have
 101 "non-standard" names, so they won't get past the parser in user code.
 102
 103
 104 %************************************************************************
 105 %*                                                                      *
 106 \subsection{RdrNames for the primops}
 107 %*                                                                      *
 108 %************************************************************************
 109
 110 These can't be in PrelNames, because we get the RdrName from the PrimOp,
 111 which is above PrelNames in the module hierarchy.
 112
 113 \begin{code}
 114 eqH_Char_RDR    = primOpRdrName CharEqOp
 115 ltH_Char_RDR    = primOpRdrName CharLtOp
 116 eqH_Word_RDR    = primOpRdrName WordEqOp
 117 ltH_Word_RDR    = primOpRdrName WordLtOp
 118 eqH_Addr_RDR    = primOpRdrName AddrEqOp
 119 ltH_Addr_RDR    = primOpRdrName AddrLtOp
 120 eqH_Float_RDR   = primOpRdrName FloatEqOp
 121 ltH_Float_RDR   = primOpRdrName FloatLtOp
 122 eqH_Double_RDR  = primOpRdrName DoubleEqOp
 123 ltH_Double_RDR  = primOpRdrName DoubleLtOp
 124 eqH_Int_RDR     = primOpRdrName IntEqOp
 125 ltH_Int_RDR     = primOpRdrName IntLtOp
 126 geH_RDR         = primOpRdrName IntGeOp
 127 leH_RDR         = primOpRdrName IntLeOp
 128 minusH_RDR      = primOpRdrName IntSubOp
 129
 130 tagToEnumH_RDR  = primOpRdrName TagToEnumOp
 131 \end{code}
 132
 133 %************************************************************************
 134 %*                                                                      *
 135 \subsection{Wired in TyCons}
 136 %*                                                                      *
 137 %************************************************************************
 138
 139 \begin{code}
 140 wired_in_tycons = [funTyCon] ++
 141                   prim_tycons ++
 142                   tuple_tycons ++
 143                   unboxed_tuple_tycons ++
 144                   data_tycons
 145
 146 prim_tycons
 147   = [ addrPrimTyCon
 148     , arrayPrimTyCon
 149     , byteArrayPrimTyCon
 150     , charPrimTyCon
 151     , doublePrimTyCon
 152     , floatPrimTyCon
 153     , intPrimTyCon
 154     , int64PrimTyCon
 155     , foreignObjPrimTyCon
 156     , bcoPrimTyCon
 157     , weakPrimTyCon
 158     , mutableArrayPrimTyCon
 159     , mutableByteArrayPrimTyCon
 160     , mVarPrimTyCon
 161     , mutVarPrimTyCon
 162     , realWorldTyCon
 163     , stablePtrPrimTyCon
 164     , stableNamePrimTyCon
 165     , statePrimTyCon
 166     , threadIdPrimTyCon
 167     , wordPrimTyCon
 168     , word64PrimTyCon
 169     ]
 170
 171 tuple_tycons = unitTyCon : [tupleTyCon Boxed i | i <- [2..37] ]
 172 unboxed_tuple_tycons = [tupleTyCon Unboxed i | i <- [1..37] ]
 173
 174 data_tycons
 175   = [ addrTyCon
 176     , boolTyCon
 177     , charTyCon
 178     , doubleTyCon
 179     , floatTyCon
 180     , intTyCon
 181     , integerTyCon
 182     , listTyCon
 183     , wordTyCon
 184     ]
 185 \end{code}
 186
 187
 188 %************************************************************************
 189 %*                                                                      *
 190 \subsection{Built-in keys}
 191 %*                                                                      *
 192 %************************************************************************
 193
 194 Ids, Synonyms, Classes and ClassOps with builtin keys.
 195
 196 \begin{code}
 197 knownKeyNames :: [Name]
 198 knownKeyNames
 199   = map mkKnownKeyGlobal
 200     [
 201         -- Type constructors (synonyms especially)
 202       (ioTyCon_RDR,             ioTyConKey)
 203     , (main_RDR,                mainKey)
 204     , (orderingTyCon_RDR,       orderingTyConKey)
 205     , (rationalTyCon_RDR,       rationalTyConKey)
 206     , (ratioDataCon_RDR,        ratioDataConKey)
 207     , (ratioTyCon_RDR,          ratioTyConKey)
 208     , (byteArrayTyCon_RDR,      byteArrayTyConKey)
 209     , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey)
 210     , (foreignObjTyCon_RDR,     foreignObjTyConKey)
 211     , (bcoPrimTyCon_RDR,        bcoPrimTyConKey)
 212     , (stablePtrTyCon_RDR,      stablePtrTyConKey)
 213     , (stablePtrDataCon_RDR,    stablePtrDataConKey)
 214
 215         --  Classes.  *Must* include:
 216         --      classes that are grabbed by key (e.g., eqClassKey)
 217         --      classes in "Class.standardClassKeys" (quite a few)
 218     , (eqClass_RDR,             eqClassKey)             -- mentioned, derivable
 219     , (ordClass_RDR,            ordClassKey)            -- derivable
 220     , (boundedClass_RDR,        boundedClassKey)        -- derivable
 221     , (numClass_RDR,            numClassKey)            -- mentioned, numeric
 222     , (enumClass_RDR,           enumClassKey)           -- derivable
 223     , (monadClass_RDR,          monadClassKey)
 224     , (monadPlusClass_RDR,      monadPlusClassKey)
 225     , (functorClass_RDR,        functorClassKey)
 226     , (showClass_RDR,           showClassKey)           -- derivable
 227     , (realClass_RDR,           realClassKey)           -- numeric
 228     , (integralClass_RDR,       integralClassKey)       -- numeric
 229     , (fractionalClass_RDR,     fractionalClassKey)     -- numeric
 230     , (floatingClass_RDR,       floatingClassKey)       -- numeric
 231     , (realFracClass_RDR,       realFracClassKey)       -- numeric
 232     , (realFloatClass_RDR,      realFloatClassKey)      -- numeric
 233     , (readClass_RDR,           readClassKey)           -- derivable
 234     , (ixClass_RDR,             ixClassKey)             -- derivable (but it isn't Prelude.Ix; hmmm)
 235     , (ccallableClass_RDR,      cCallableClassKey)      -- mentioned, ccallish
 236     , (creturnableClass_RDR,    cReturnableClassKey)    -- mentioned, ccallish
 237
 238         -- ClassOps
 239     , (fromInt_RDR,             fromIntClassOpKey)
 240     , (fromInteger_RDR,         fromIntegerClassOpKey)
 241     , (ge_RDR,                  geClassOpKey)
 242     , (minus_RDR,               minusClassOpKey)
 243     , (enumFrom_RDR,            enumFromClassOpKey)
 244     , (enumFromThen_RDR,        enumFromThenClassOpKey)
 245     , (enumFromTo_RDR,          enumFromToClassOpKey)
 246     , (enumFromThenTo_RDR,      enumFromThenToClassOpKey)
 247     , (fromEnum_RDR,            fromEnumClassOpKey)
 248     , (toEnum_RDR,              toEnumClassOpKey)
 249     , (eq_RDR,                  eqClassOpKey)
 250     , (thenM_RDR,               thenMClassOpKey)
 251     , (returnM_RDR,             returnMClassOpKey)
 252     , (failM_RDR,               failMClassOpKey)
 253     , (fromRational_RDR,        fromRationalClassOpKey)
 254
 255     , (deRefStablePtr_RDR,      deRefStablePtrIdKey)
 256     , (makeStablePtr_RDR,       makeStablePtrIdKey)
 257     , (bindIO_RDR,              bindIOIdKey)
 258     , (returnIO_RDR,            returnIOIdKey)
 259
 260         -- Strings and lists
 261     , (map_RDR,                 mapIdKey)
 262     , (append_RDR,              appendIdKey)
 263     , (unpackCString_RDR,       unpackCStringIdKey)
 264     , (unpackCStringAppend_RDR, unpackCStringAppendIdKey)
 265     , (unpackCStringFoldr_RDR,  unpackCStringFoldrIdKey)
 266     , (unpackCStringUtf8_RDR,   unpackCStringUtf8IdKey)
 267
 268         -- List operations
 269     , (concat_RDR,              concatIdKey)
 270     , (filter_RDR,              filterIdKey)
 271     , (zip_RDR,                 zipIdKey)
 272     , (foldr_RDR,               foldrIdKey)
 273     , (build_RDR,               buildIdKey)
 274     , (augment_RDR,             augmentIdKey)
 275
 276         -- FFI primitive types that are not wired-in.
 277     , (int8TyCon_RDR,           int8TyConKey)
 278     , (int16TyCon_RDR,          int16TyConKey)
 279     , (int32TyCon_RDR,          int32TyConKey)
 280     , (int64TyCon_RDR,          int64TyConKey)
 281     , (word8TyCon_RDR,          word8TyConKey)
 282     , (word16TyCon_RDR,         word16TyConKey)
 283     , (word32TyCon_RDR,         word32TyConKey)
 284     , (word64TyCon_RDR,         word64TyConKey)
 285
 286         -- Others
 287     , (otherwiseId_RDR,         otherwiseIdKey)
 288     , (plusInteger_RDR,         plusIntegerIdKey)
 289     , (timesInteger_RDR,        timesIntegerIdKey)
 290     , (eqString_RDR,            eqStringIdKey)
 291     , (assert_RDR,              assertIdKey)
 292     , (runSTRep_RDR,            runSTRepIdKey)
 293     ]
 294 \end{code}
 295
 296 ToDo: make it do the ``like'' part properly (as in 0.26 and before).
 297
 298 \begin{code}
 299 maybeCharLikeCon, maybeIntLikeCon :: DataCon -> Bool
 300 maybeCharLikeCon con = con `hasKey` charDataConKey
 301 maybeIntLikeCon  con = con `hasKey` intDataConKey
 302 \end{code}
 303
 304 %************************************************************************
 305 %*                                                                      *
 306 \subsection[Class-std-groups]{Standard groups of Prelude classes}
 307 %*                                                                      *
 308 %************************************************************************
 309
 310 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
 311 (@TcDeriv@).
 312
 313 @derivingOccurrences@ maps a class name to a list of the (qualified) occurrences
 314 that will be mentioned by  the derived code for the class when it is later generated.
 315 We don't need to put in things that are WiredIn (because they are already mapped to their
 316 correct name by the @NameSupply@.  The class itself, and all its class ops, is
 317 already flagged as an occurrence so we don't need to mention that either.
 318
 319 @derivingOccurrences@ has an item for every derivable class, even if that item is empty,
 320 because we treat lookup failure as indicating that the class is illegal in a deriving clause.
 321
 322 \begin{code}
 323 derivingOccurrences :: UniqFM [RdrName]
 324 derivingOccurrences = listToUFM deriving_occ_info
 325
 326 derivableClassKeys  = map fst deriving_occ_info
 327
 328 deriving_occ_info
 329   = [ (eqClassKey,      [intTyCon_RDR, and_RDR, not_RDR])
 330     , (ordClassKey,     [intTyCon_RDR, compose_RDR, eqTag_RDR])
 331                                 -- EQ (from Ordering) is needed to force in the constructors
 332                                 -- as well as the type constructor.
 333     , (enumClassKey,    [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
 334                                 -- The last two Enum deps are only used to produce better
 335                                 -- error msgs for derived toEnum methods.
 336     , (boundedClassKey, [intTyCon_RDR])
 337     , (showClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
 338                          showParen_RDR, showSpace_RDR, showList___RDR])
 339     , (readClassKey,    [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
 340                          foldr_RDR, build_RDR,
 341                              -- foldr and build required for list comprehension
 342                              -- KSW 2000-06
 343                          lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
 344                              -- returnM (and the rest of the Monad class decl)
 345                              -- will be forced in as result of depending
 346                              -- on thenM.   -- SOF 1/99
 347     , (ixClassKey,      [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
 348                          foldr_RDR, build_RDR,
 349                              -- foldr and build required for list comprehension used
 350                              -- with single constructor types  -- KSW 2000-06
 351                          returnM_RDR, failM_RDR])
 352                              -- the last two are needed to force returnM, thenM and failM
 353                              -- in before typechecking the list(monad) comprehension
 354                              -- generated for derived Ix instances (range method)
 355                              -- of single constructor types.  -- SOF 8/97
 356     ]
 357         -- intTyCon: Practically any deriving needs Int, either for index calculations,
 358         --              or for taggery.
 359         -- ordClass: really it's the methods that are actually used.
 360         -- numClass: for Int literals
 361 \end{code}
 362
 363
 364 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
 365 even though every numeric class has these two as a superclass,
 366 because the list of ambiguous dictionaries hasn't been simplified.
 367
 368 \begin{code}
 369 isCcallishClass, isCreturnableClass, isNoDictClass,
 370   isNumericClass, isStandardClass :: Class -> Bool
 371
 372 isNumericClass     clas = classKey clas `is_elem` numericClassKeys
 373 isStandardClass    clas = classKey clas `is_elem` standardClassKeys
 374 isCcallishClass    clas = classKey clas `is_elem` cCallishClassKeys
 375 isCreturnableClass clas = classKey clas == cReturnableClassKey
 376 isNoDictClass      clas = classKey clas `is_elem` noDictClassKeys
 377 is_elem = isIn "is_X_Class"
 378
 379 numericClassKeys =
 380         [ numClassKey
 381         , realClassKey
 382         , integralClassKey
 383         ]
 384         ++ fractionalClassKeys
 385
 386 fractionalClassKeys =
 387         [ fractionalClassKey
 388         , floatingClassKey
 389         , realFracClassKey
 390         , realFloatClassKey
 391         ]
 392
 393         -- the strictness analyser needs to know about numeric types
 394         -- (see SaAbsInt.lhs)
 395 numericTyKeys =
 396         [ addrTyConKey
 397         , wordTyConKey
 398         , intTyConKey
 399         , integerTyConKey
 400         , doubleTyConKey
 401         , floatTyConKey
 402         ]
 403
 404 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
 405         [ readClassKey
 406         ]
 407
 408 cCallishClassKeys =
 409         [ cCallableClassKey
 410         , cReturnableClassKey
 411         ]
 412
 413         -- Renamer always imports these data decls replete with constructors
 414         -- so that desugarer can always see their constructors.  Ugh!
 415 cCallishTyKeys =
 416         [ addrTyConKey
 417         , wordTyConKey
 418         , byteArrayTyConKey
 419         , mutableByteArrayTyConKey
 420         , foreignObjTyConKey
 421         , stablePtrTyConKey
 422         , int8TyConKey
 423         , int16TyConKey
 424         , int32TyConKey
 425         , int64TyConKey
 426         , word8TyConKey
 427         , word16TyConKey
 428         , word32TyConKey
 429         , word64TyConKey
 430         ]
 431
 432 standardClassKeys
 433   = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
 434     --
 435     -- We have to have "CCallable" and "CReturnable" in the standard
 436     -- classes, so that if you go...
 437     --
 438     --      _ccall_ foo ... 93{-numeric literal-} ...
 439     --
 440     -- ... it can do The Right Thing on the 93.
 441
 442 noDictClassKeys         -- These classes are used only for type annotations;
 443                         -- they are not implemented by dictionaries, ever.
 444   = cCallishClassKeys
 445 \end{code}
 446