2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[PrelInfo]{The @PrelInfo@ interface to the compiler's prelude knowledge}
8 builtinNames, -- Names of things whose *unique* must be known, but
9 -- that is all. If something is in here, you know that
10 -- if it's used at all then it's Name will be just as
11 -- it is here, unique and all. Includes all the
14 thinAirIdNames, -- Names of non-wired-in Ids that may be used out of
15 setThinAirIds, -- thin air in any compilation. If they are not wired in
16 thinAirModules, -- we must be sure to import them from some Prelude
17 -- interface file even if they are not overtly
18 -- mentioned. Subset of builtinNames.
22 derivingOccurrences, -- For a given class C, this tells what other
23 -- things are needed as a result of a
27 -- Here are the thin-air Ids themselves
28 int2IntegerId, addr2IntegerId,
29 integerMinusOneId, integerZeroId, integerPlusOneId, integerPlusTwoId,
30 packStringForCId, unpackCStringId, unpackCString2Id,
31 unpackCStringAppendId, unpackCStringFoldrId,
34 -- Random other things
35 main_NAME, ioTyCon_NAME,
36 deRefStablePtr_NAME, makeStablePtr_NAME,
39 maybeCharLikeCon, maybeIntLikeCon,
40 needsDataDeclCtxtClassKeys, cCallishClassKeys, cCallishTyKeys,
41 isNoDictClass, isNumericClass, isStandardClass, isCcallishClass,
42 isCreturnableClass, numericTyKeys,
44 -- RdrNames for lots of things, mainly used in derivings
45 eq_RDR, ne_RDR, le_RDR, lt_RDR, ge_RDR, gt_RDR, max_RDR, min_RDR,
46 compare_RDR, minBound_RDR, maxBound_RDR, enumFrom_RDR, enumFromTo_RDR,
47 enumFromThen_RDR, enumFromThenTo_RDR, succ_RDR, pred_RDR, fromEnum_RDR, toEnum_RDR,
48 ratioDataCon_RDR, range_RDR, index_RDR, inRange_RDR, readsPrec_RDR,
49 readList_RDR, showsPrec_RDR, showList_RDR, plus_RDR, times_RDR,
50 ltTag_RDR, eqTag_RDR, gtTag_RDR, eqH_Char_RDR, ltH_Char_RDR,
51 eqH_Word_RDR, ltH_Word_RDR, eqH_Addr_RDR, ltH_Addr_RDR, eqH_Float_RDR,
52 ltH_Float_RDR, eqH_Double_RDR, ltH_Double_RDR, eqH_Int_RDR,
53 ltH_Int_RDR, geH_RDR, leH_RDR, minusH_RDR, false_RDR, true_RDR,
54 and_RDR, not_RDR, append_RDR, map_RDR, compose_RDR, mkInt_RDR,
55 error_RDR, assertErr_RDR,
56 showString_RDR, showParen_RDR, readParen_RDR, lex_RDR,
57 showSpace_RDR, showList___RDR, readList___RDR, negate_RDR,
59 numClass_RDR, fractionalClass_RDR, eqClass_RDR,
60 ccallableClass_RDR, creturnableClass_RDR,
61 monadClass_RDR, enumClass_RDR, ordClass_RDR,
64 mkTupConRdrName, mkUbxTupConRdrName
68 #include "HsVersions.h"
72 import PrelMods -- Prelude module names
73 import PrelVals -- VALUES
74 import MkId ( mkPrimitiveId )
75 import PrimOp ( PrimOp(..), allThePrimOps )
76 import DataCon ( DataCon )
77 import PrimRep ( PrimRep(..) )
78 import TysPrim -- TYPES
82 import RdrName ( RdrName, mkPreludeQual )
83 import Var ( varUnique, Id )
84 import Name ( Name, OccName, Provenance(..),
85 NameSpace, tcName, clsName, varName, dataName,
86 getName, mkGlobalName, nameRdrName, systemProvenance
88 import RdrName ( rdrNameModule, rdrNameOcc, mkSrcQual )
89 import Class ( Class, classKey )
90 import TyCon ( tyConDataCons, TyCon )
91 import Type ( funTyCon )
93 import Unique -- *Key stuff
94 import UniqFM ( UniqFM, listToUFM, lookupWithDefaultUFM )
96 import Panic ( panic )
101 %************************************************************************
103 \subsection[builtinNameInfo]{Lookup built-in names}
105 %************************************************************************
107 We have two ``builtin name funs,'' one to look up @TyCons@ and
108 @Classes@, the other to look up values.
111 builtinNames :: Bag Name
115 unionManyBags (map getTyConNames wired_in_tycons)
118 , listToBag (map getName wired_in_ids)
121 , listToBag (map (getName . mkPrimitiveId) allThePrimOps)
124 , listToBag thinAirIdNames
126 -- Other names with magic keys
127 , listToBag knownKeyNames
133 getTyConNames :: TyCon -> Bag Name
135 = getName tycon `consBag`
136 listToBag (map getName (tyConDataCons tycon))
137 -- Synonyms return empty list of constructors
140 We let a lot of "non-standard" values be visible, so that we can make
141 sense of them in interface pragmas. It's cool, though they all have
142 "non-standard" names, so they won't get past the parser in user code.
145 %************************************************************************
147 \subsection{Wired in TyCons}
149 %************************************************************************
152 wired_in_tycons = [funTyCon] ++
155 unboxed_tuple_tycons ++
167 , foreignObjPrimTyCon
169 , mutableArrayPrimTyCon
170 , mutableByteArrayPrimTyCon
175 , stableNamePrimTyCon
182 tuple_tycons = unitTyCon : [tupleTyCon i | i <- [2..37] ]
183 unboxed_tuple_tycons = [unboxedTupleTyCon i | i <- [1..37] ]
207 %************************************************************************
209 \subsection{Wired in Ids}
211 %************************************************************************
215 = [ -- These error-y things are wired in because we don't yet have
216 -- a way to express in an interface file that the result type variable
217 -- is 'open'; that is can be unified with an unboxed type
219 -- [The interface file format now carry such information, but there's
220 -- no way yet of expressing at the definition site for these error-reporting
221 -- functions that they have an 'open' result type. -- sof 1/99]
225 , iRREFUT_PAT_ERROR_ID
226 , nON_EXHAUSTIVE_GUARDS_ERROR_ID
227 , nO_METHOD_BINDING_ERROR_ID
233 -- These two can't be defined in Haskell
240 %************************************************************************
242 \subsection{Thin air entities}
244 %************************************************************************
246 These are Ids that we need to reference in various parts of the
247 system, and we'd like to pull them out of thin air rather than pass
248 them around. We'd also like to have all the IdInfo available for each
249 one: i.e. everything that gets pulled out of the interface file.
251 The solution is to generate this map of global Ids after the
252 typechecker, and assign it to a global variable. Any subsequent
253 pass may refer to the map to pull Ids out. Any invalid
254 (i.e. pre-typechecker) access to the map will result in a panic.
258 = map mkKnownKeyGlobal
260 -- Needed for converting literals to Integers (used in tidyCoreExpr)
261 (varQual pREL_BASE SLIT("int2Integer"), int2IntegerIdKey)
262 , (varQual pREL_BASE SLIT("addr2Integer"), addr2IntegerIdKey)
264 -- OK, this is Will's idea: we should have magic values for Integers 0,
265 -- +1, +2, and -1 (go ahead, fire me):
266 , (varQual pREL_BASE SLIT("integer_0"), integerZeroIdKey)
267 , (varQual pREL_BASE SLIT("integer_1"), integerPlusOneIdKey)
268 , (varQual pREL_BASE SLIT("integer_2"), integerPlusTwoIdKey)
269 , (varQual pREL_BASE SLIT("integer_m1"), integerMinusOneIdKey)
273 , (varQual pREL_PACK SLIT("packCString#"), packCStringIdKey)
274 , (varQual pREL_PACK SLIT("unpackCString#"), unpackCStringIdKey)
275 , (varQual pREL_PACK SLIT("unpackNBytes#"), unpackCString2IdKey)
276 , (varQual pREL_PACK SLIT("unpackAppendCString#"), unpackCStringAppendIdKey)
277 , (varQual pREL_PACK SLIT("unpackFoldrCString#"), unpackCStringFoldrIdKey)
279 -- Folds; introduced by desugaring list comprehensions
280 , (varQual pREL_BASE SLIT("foldr"), foldrIdKey)
283 thinAirModules = [pREL_PACK] -- See notes with RnIfaces.findAndReadIface
285 noRepIntegerIds = [integerZeroId, integerPlusOneId, integerPlusTwoId, integerMinusOneId,
286 int2IntegerId, addr2IntegerId]
288 noRepStrIds = [unpackCString2Id, unpackCStringId]
290 int2IntegerId = lookupThinAirId int2IntegerIdKey
291 addr2IntegerId = lookupThinAirId addr2IntegerIdKey
293 integerMinusOneId = lookupThinAirId integerMinusOneIdKey
294 integerZeroId = lookupThinAirId integerZeroIdKey
295 integerPlusOneId = lookupThinAirId integerPlusOneIdKey
296 integerPlusTwoId = lookupThinAirId integerPlusTwoIdKey
298 packStringForCId = lookupThinAirId packCStringIdKey
299 unpackCStringId = lookupThinAirId unpackCStringIdKey
300 unpackCString2Id = lookupThinAirId unpackCString2IdKey
301 unpackCStringAppendId = lookupThinAirId unpackCStringAppendIdKey
302 unpackCStringFoldrId = lookupThinAirId unpackCStringFoldrIdKey
304 foldrId = lookupThinAirId foldrIdKey
312 thinAirIdMapRef :: IORef (UniqFM Id)
313 thinAirIdMapRef = unsafePerformIO (newIORef (panic "thinAirIdMap: still empty"))
315 setThinAirIds :: [Id] -> IO ()
316 setThinAirIds thin_air_ids
317 = writeIORef thinAirIdMapRef the_map
319 the_map = listToUFM [(varUnique id, id) | id <- thin_air_ids]
321 thinAirIdMap :: UniqFM Id
322 thinAirIdMap = unsafePerformIO (readIORef thinAirIdMapRef)
323 -- Read it just once, the first time someone tugs on thinAirIdMap
325 lookupThinAirId :: Unique -> Id
326 lookupThinAirId uniq = lookupWithDefaultUFM thinAirIdMap
327 (panic "lookupThinAirId: no mapping") uniq
331 %************************************************************************
333 \subsection{Built-in keys}
335 %************************************************************************
337 Ids, Synonyms, Classes and ClassOps with builtin keys.
340 mkKnownKeyGlobal :: (RdrName, Unique) -> Name
341 mkKnownKeyGlobal (rdr_name, uniq)
342 = mkGlobalName uniq (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
345 ioTyCon_NAME = mkKnownKeyGlobal (ioTyCon_RDR, ioTyConKey)
346 main_NAME = mkKnownKeyGlobal (main_RDR, mainKey)
348 -- Operations needed when compiling FFI decls
349 bindIO_NAME = mkKnownKeyGlobal (bindIO_RDR, bindIOIdKey)
350 deRefStablePtr_NAME = mkKnownKeyGlobal (deRefStablePtr_RDR, deRefStablePtrIdKey)
351 makeStablePtr_NAME = mkKnownKeyGlobal (makeStablePtr_RDR, makeStablePtrIdKey)
353 knownKeyNames :: [Name]
355 = [main_NAME, ioTyCon_NAME]
359 -- Type constructors (synonyms especially)
360 (orderingTyCon_RDR, orderingTyConKey)
361 , (rationalTyCon_RDR, rationalTyConKey)
362 , (ratioDataCon_RDR, ratioDataConKey)
363 , (ratioTyCon_RDR, ratioTyConKey)
364 , (byteArrayTyCon_RDR, byteArrayTyConKey)
365 , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey)
366 , (foreignObjTyCon_RDR, foreignObjTyConKey)
367 , (stablePtrTyCon_RDR, stablePtrTyConKey)
368 , (stablePtrDataCon_RDR, stablePtrDataConKey)
370 -- Classes. *Must* include:
371 -- classes that are grabbed by key (e.g., eqClassKey)
372 -- classes in "Class.standardClassKeys" (quite a few)
373 , (eqClass_RDR, eqClassKey) -- mentioned, derivable
374 , (ordClass_RDR, ordClassKey) -- derivable
375 , (boundedClass_RDR, boundedClassKey) -- derivable
376 , (numClass_RDR, numClassKey) -- mentioned, numeric
377 , (enumClass_RDR, enumClassKey) -- derivable
378 , (monadClass_RDR, monadClassKey)
379 , (monadPlusClass_RDR, monadPlusClassKey)
380 , (functorClass_RDR, functorClassKey)
381 , (showClass_RDR, showClassKey) -- derivable
382 , (realClass_RDR, realClassKey) -- numeric
383 , (integralClass_RDR, integralClassKey) -- numeric
384 , (fractionalClass_RDR, fractionalClassKey) -- numeric
385 , (floatingClass_RDR, floatingClassKey) -- numeric
386 , (realFracClass_RDR, realFracClassKey) -- numeric
387 , (realFloatClass_RDR, realFloatClassKey) -- numeric
388 , (readClass_RDR, readClassKey) -- derivable
389 , (ixClass_RDR, ixClassKey) -- derivable (but it isn't Prelude.Ix; hmmm)
390 , (ccallableClass_RDR, cCallableClassKey) -- mentioned, ccallish
391 , (creturnableClass_RDR, cReturnableClassKey) -- mentioned, ccallish
394 , (fromInt_RDR, fromIntClassOpKey)
395 , (fromInteger_RDR, fromIntegerClassOpKey)
396 , (ge_RDR, geClassOpKey)
397 , (minus_RDR, minusClassOpKey)
398 , (enumFrom_RDR, enumFromClassOpKey)
399 , (enumFromThen_RDR, enumFromThenClassOpKey)
400 , (enumFromTo_RDR, enumFromToClassOpKey)
401 , (enumFromThenTo_RDR, enumFromThenToClassOpKey)
402 , (fromEnum_RDR, fromEnumClassOpKey)
403 , (toEnum_RDR, toEnumClassOpKey)
404 , (eq_RDR, eqClassOpKey)
405 , (thenM_RDR, thenMClassOpKey)
406 , (returnM_RDR, returnMClassOpKey)
407 , (failM_RDR, failMClassOpKey)
408 , (fromRational_RDR, fromRationalClassOpKey)
410 , (deRefStablePtr_RDR, deRefStablePtrIdKey)
411 , (makeStablePtr_RDR, makeStablePtrIdKey)
412 , (bindIO_RDR, bindIOIdKey)
414 , (map_RDR, mapIdKey)
415 , (append_RDR, appendIdKey)
418 , (concat_RDR, concatIdKey)
419 , (filter_RDR, filterIdKey)
420 , (zip_RDR, zipIdKey)
423 , (otherwiseId_RDR, otherwiseIdKey)
424 , (assert_RDR, assertIdKey)
428 ToDo: make it do the ``like'' part properly (as in 0.26 and before).
431 maybeCharLikeCon, maybeIntLikeCon :: DataCon -> Bool
432 maybeCharLikeCon con = getUnique con == charDataConKey
433 maybeIntLikeCon con = getUnique con == intDataConKey
436 %************************************************************************
438 \subsection{Commonly-used RdrNames}
440 %************************************************************************
442 These RdrNames are not really "built in", but some parts of the compiler
443 (notably the deriving mechanism) need to mention their names, and it's convenient
444 to write them all down in one place.
447 prelude_primop op = nameRdrName (getName (mkPrimitiveId op))
449 main_RDR = varQual mAIN SLIT("main")
450 otherwiseId_RDR = varQual pREL_BASE SLIT("otherwise")
452 intTyCon_RDR = nameRdrName (getName intTyCon)
453 ioTyCon_RDR = tcQual pREL_IO_BASE SLIT("IO")
454 ioDataCon_RDR = dataQual pREL_IO_BASE SLIT("IO")
455 bindIO_RDR = varQual pREL_IO_BASE SLIT("bindIO")
457 orderingTyCon_RDR = tcQual pREL_BASE SLIT("Ordering")
458 rationalTyCon_RDR = tcQual pREL_NUM SLIT("Rational")
459 ratioTyCon_RDR = tcQual pREL_NUM SLIT("Ratio")
460 ratioDataCon_RDR = dataQual pREL_NUM SLIT(":%")
462 byteArrayTyCon_RDR = tcQual pREL_ARR SLIT("ByteArray")
463 mutableByteArrayTyCon_RDR = tcQual pREL_ARR SLIT("MutableByteArray")
465 foreignObjTyCon_RDR = tcQual pREL_IO_BASE SLIT("ForeignObj")
466 stablePtrTyCon_RDR = tcQual pREL_STABLE SLIT("StablePtr")
467 stablePtrDataCon_RDR = dataQual pREL_STABLE SLIT("StablePtr")
468 deRefStablePtr_RDR = varQual pREL_STABLE SLIT("deRefStablePtr")
469 makeStablePtr_RDR = varQual pREL_STABLE SLIT("makeStablePtr")
471 eqClass_RDR = clsQual pREL_BASE SLIT("Eq")
472 ordClass_RDR = clsQual pREL_BASE SLIT("Ord")
473 boundedClass_RDR = clsQual pREL_BASE SLIT("Bounded")
474 numClass_RDR = clsQual pREL_BASE SLIT("Num")
475 enumClass_RDR = clsQual pREL_BASE SLIT("Enum")
476 monadClass_RDR = clsQual pREL_BASE SLIT("Monad")
477 monadPlusClass_RDR = clsQual pREL_BASE SLIT("MonadPlus")
478 functorClass_RDR = clsQual pREL_BASE SLIT("Functor")
479 showClass_RDR = clsQual pREL_BASE SLIT("Show")
480 realClass_RDR = clsQual pREL_NUM SLIT("Real")
481 integralClass_RDR = clsQual pREL_NUM SLIT("Integral")
482 fractionalClass_RDR = clsQual pREL_NUM SLIT("Fractional")
483 floatingClass_RDR = clsQual pREL_NUM SLIT("Floating")
484 realFracClass_RDR = clsQual pREL_NUM SLIT("RealFrac")
485 realFloatClass_RDR = clsQual pREL_NUM SLIT("RealFloat")
486 readClass_RDR = clsQual pREL_READ SLIT("Read")
487 ixClass_RDR = clsQual iX SLIT("Ix")
488 ccallableClass_RDR = clsQual pREL_GHC SLIT("CCallable")
489 creturnableClass_RDR = clsQual pREL_GHC SLIT("CReturnable")
491 fromInt_RDR = varQual pREL_BASE SLIT("fromInt")
492 fromInteger_RDR = varQual pREL_BASE SLIT("fromInteger")
493 minus_RDR = varQual pREL_BASE SLIT("-")
494 succ_RDR = varQual pREL_BASE SLIT("succ")
495 pred_RDR = varQual pREL_BASE SLIT("pred")
496 toEnum_RDR = varQual pREL_BASE SLIT("toEnum")
497 fromEnum_RDR = varQual pREL_BASE SLIT("fromEnum")
498 enumFrom_RDR = varQual pREL_BASE SLIT("enumFrom")
499 enumFromTo_RDR = varQual pREL_BASE SLIT("enumFromTo")
500 enumFromThen_RDR = varQual pREL_BASE SLIT("enumFromThen")
501 enumFromThenTo_RDR = varQual pREL_BASE SLIT("enumFromThenTo")
503 thenM_RDR = varQual pREL_BASE SLIT(">>=")
504 returnM_RDR = varQual pREL_BASE SLIT("return")
505 failM_RDR = varQual pREL_BASE SLIT("fail")
507 fromRational_RDR = varQual pREL_NUM SLIT("fromRational")
508 negate_RDR = varQual pREL_BASE SLIT("negate")
509 eq_RDR = varQual pREL_BASE SLIT("==")
510 ne_RDR = varQual pREL_BASE SLIT("/=")
511 le_RDR = varQual pREL_BASE SLIT("<=")
512 lt_RDR = varQual pREL_BASE SLIT("<")
513 ge_RDR = varQual pREL_BASE SLIT(">=")
514 gt_RDR = varQual pREL_BASE SLIT(">")
515 ltTag_RDR = dataQual pREL_BASE SLIT("LT")
516 eqTag_RDR = dataQual pREL_BASE SLIT("EQ")
517 gtTag_RDR = dataQual pREL_BASE SLIT("GT")
518 max_RDR = varQual pREL_BASE SLIT("max")
519 min_RDR = varQual pREL_BASE SLIT("min")
520 compare_RDR = varQual pREL_BASE SLIT("compare")
521 minBound_RDR = varQual pREL_BASE SLIT("minBound")
522 maxBound_RDR = varQual pREL_BASE SLIT("maxBound")
523 false_RDR = dataQual pREL_BASE SLIT("False")
524 true_RDR = dataQual pREL_BASE SLIT("True")
525 and_RDR = varQual pREL_BASE SLIT("&&")
526 not_RDR = varQual pREL_BASE SLIT("not")
527 compose_RDR = varQual pREL_BASE SLIT(".")
528 append_RDR = varQual pREL_BASE SLIT("++")
529 map_RDR = varQual pREL_BASE SLIT("map")
530 concat_RDR = varQual mONAD SLIT("concat")
531 filter_RDR = varQual mONAD SLIT("filter")
532 zip_RDR = varQual pREL_LIST SLIT("zip")
534 showList___RDR = varQual pREL_BASE SLIT("showList__")
535 showsPrec_RDR = varQual pREL_BASE SLIT("showsPrec")
536 showList_RDR = varQual pREL_BASE SLIT("showList")
537 showSpace_RDR = varQual pREL_BASE SLIT("showSpace")
538 showString_RDR = varQual pREL_BASE SLIT("showString")
539 showParen_RDR = varQual pREL_BASE SLIT("showParen")
541 range_RDR = varQual iX SLIT("range")
542 index_RDR = varQual iX SLIT("index")
543 inRange_RDR = varQual iX SLIT("inRange")
545 readsPrec_RDR = varQual pREL_READ SLIT("readsPrec")
546 readList_RDR = varQual pREL_READ SLIT("readList")
547 readParen_RDR = varQual pREL_READ SLIT("readParen")
548 lex_RDR = varQual pREL_READ SLIT("lex")
549 readList___RDR = varQual pREL_READ SLIT("readList__")
551 plus_RDR = varQual pREL_BASE SLIT("+")
552 times_RDR = varQual pREL_BASE SLIT("*")
553 mkInt_RDR = dataQual pREL_BASE SLIT("I#")
555 error_RDR = varQual pREL_ERR SLIT("error")
556 assert_RDR = varQual pREL_GHC SLIT("assert")
557 assertErr_RDR = varQual pREL_ERR SLIT("assertError")
559 eqH_Char_RDR = prelude_primop CharEqOp
560 ltH_Char_RDR = prelude_primop CharLtOp
561 eqH_Word_RDR = prelude_primop WordEqOp
562 ltH_Word_RDR = prelude_primop WordLtOp
563 eqH_Addr_RDR = prelude_primop AddrEqOp
564 ltH_Addr_RDR = prelude_primop AddrLtOp
565 eqH_Float_RDR = prelude_primop FloatEqOp
566 ltH_Float_RDR = prelude_primop FloatLtOp
567 eqH_Double_RDR = prelude_primop DoubleEqOp
568 ltH_Double_RDR = prelude_primop DoubleLtOp
569 eqH_Int_RDR = prelude_primop IntEqOp
570 ltH_Int_RDR = prelude_primop IntLtOp
571 geH_RDR = prelude_primop IntGeOp
572 leH_RDR = prelude_primop IntLeOp
573 minusH_RDR = prelude_primop IntSubOp
577 mkTupConRdrName :: Int -> RdrName
578 mkTupConRdrName arity = case mkTupNameStr arity of
579 (mod, occ) -> dataQual mod occ
581 mkUbxTupConRdrName :: Int -> RdrName
582 mkUbxTupConRdrName arity = case mkUbxTupNameStr arity of
583 (mod, occ) -> dataQual mod occ
587 %************************************************************************
589 \subsection[Class-std-groups]{Standard groups of Prelude classes}
591 %************************************************************************
593 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
596 @derivingOccurrences@ maps a class name to a list of the (qualified) occurrences
597 that will be mentioned by the derived code for the class when it is later generated.
598 We don't need to put in things that are WiredIn (because they are already mapped to their
599 correct name by the @NameSupply@. The class itself, and all its class ops, is
600 already flagged as an occurrence so we don't need to mention that either.
602 @derivingOccurrences@ has an item for every derivable class, even if that item is empty,
603 because we treat lookup failure as indicating that the class is illegal in a deriving clause.
606 derivingOccurrences :: UniqFM [RdrName]
607 derivingOccurrences = listToUFM deriving_occ_info
609 derivableClassKeys = map fst deriving_occ_info
612 = [ (eqClassKey, [intTyCon_RDR, and_RDR, not_RDR])
613 , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR])
614 -- EQ (from Ordering) is needed to force in the constructors
615 -- as well as the type constructor.
616 , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
617 -- The last two Enum deps are only used to produce better
618 -- error msgs for derived toEnum methods.
619 , (boundedClassKey, [intTyCon_RDR])
620 , (showClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
621 showParen_RDR, showSpace_RDR, showList___RDR])
622 , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
623 lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
624 -- returnM (and the rest of the Monad class decl)
625 -- will be forced in as result of depending
626 -- on thenM. -- SOF 1/99
627 , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
628 returnM_RDR, failM_RDR])
629 -- the last two are needed to force returnM, thenM and failM
630 -- in before typechecking the list(monad) comprehension
631 -- generated for derived Ix instances (range method)
632 -- of single constructor types. -- SOF 8/97
634 -- intTyCon: Practically any deriving needs Int, either for index calculations,
636 -- ordClass: really it's the methods that are actually used.
637 -- numClass: for Int literals
641 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
642 even though every numeric class has these two as a superclass,
643 because the list of ambiguous dictionaries hasn't been simplified.
646 isCcallishClass, isCreturnableClass, isNoDictClass,
647 isNumericClass, isStandardClass :: Class -> Bool
649 isNumericClass clas = classKey clas `is_elem` numericClassKeys
650 isStandardClass clas = classKey clas `is_elem` standardClassKeys
651 isCcallishClass clas = classKey clas `is_elem` cCallishClassKeys
652 isCreturnableClass clas = classKey clas == cReturnableClassKey
653 isNoDictClass clas = classKey clas `is_elem` noDictClassKeys
654 is_elem = isIn "is_X_Class"
666 -- the strictness analyser needs to know about numeric types
667 -- (see SaAbsInt.lhs)
677 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
683 , cReturnableClassKey
686 -- Renamer always imports these data decls replete with constructors
687 -- so that desugarer can always see the constructor. Ugh!
692 , mutableByteArrayTyConKey
698 = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
700 -- We have to have "CCallable" and "CReturnable" in the standard
701 -- classes, so that if you go...
703 -- _ccall_ foo ... 93{-numeric literal-} ...
705 -- ... it can do The Right Thing on the 93.
707 noDictClassKeys -- These classes are used only for type annotations;
708 -- they are not implemented by dictionaries, ever.
713 %************************************************************************
715 \subsection{Local helpers}
717 %************************************************************************
720 varQual = mkPreludeQual varName
721 dataQual = mkPreludeQual dataName
722 tcQual = mkPreludeQual tcName
723 clsQual = mkPreludeQual clsName