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
29 packStringForCId, unpackCStringId, unpackCString2Id,
30 unpackCStringAppendId, unpackCStringFoldrId,
33 -- Random other things
34 main_NAME, ioTyCon_NAME,
35 deRefStablePtr_NAME, makeStablePtr_NAME,
38 maybeCharLikeCon, maybeIntLikeCon,
39 needsDataDeclCtxtClassKeys, cCallishClassKeys, cCallishTyKeys,
40 isNoDictClass, isNumericClass, isStandardClass, isCcallishClass,
41 isCreturnableClass, numericTyKeys,
43 -- RdrNames for lots of things, mainly used in derivings
44 eq_RDR, ne_RDR, le_RDR, lt_RDR, ge_RDR, gt_RDR, max_RDR, min_RDR,
45 compare_RDR, minBound_RDR, maxBound_RDR, enumFrom_RDR, enumFromTo_RDR,
46 enumFromThen_RDR, enumFromThenTo_RDR, succ_RDR, pred_RDR, fromEnum_RDR, toEnum_RDR,
47 ratioDataCon_RDR, range_RDR, index_RDR, inRange_RDR, readsPrec_RDR,
48 readList_RDR, showsPrec_RDR, showList_RDR, plus_RDR, times_RDR,
49 ltTag_RDR, eqTag_RDR, gtTag_RDR, eqH_Char_RDR, ltH_Char_RDR,
50 eqH_Word_RDR, ltH_Word_RDR, eqH_Addr_RDR, ltH_Addr_RDR, eqH_Float_RDR,
51 ltH_Float_RDR, eqH_Double_RDR, ltH_Double_RDR, eqH_Int_RDR,
52 ltH_Int_RDR, geH_RDR, leH_RDR, minusH_RDR, false_RDR, true_RDR,
53 and_RDR, not_RDR, append_RDR, map_RDR, compose_RDR, mkInt_RDR,
54 error_RDR, assertErr_RDR, getTag_RDR, tagToEnumH_RDR,
55 showString_RDR, showParen_RDR, readParen_RDR, lex_RDR,
56 showSpace_RDR, showList___RDR, readList___RDR, negate_RDR,
58 numClass_RDR, fractionalClass_RDR, eqClass_RDR,
59 ccallableClass_RDR, creturnableClass_RDR,
60 monadClass_RDR, enumClass_RDR, ordClass_RDR,
63 mkTupConRdrName, mkUbxTupConRdrName
67 #include "HsVersions.h"
71 import PrelMods -- Prelude module names
72 import PrelVals -- VALUES
73 import MkId ( mkPrimitiveId )
74 import PrimOp ( PrimOp(..), allThePrimOps )
75 import DataCon ( DataCon )
76 import PrimRep ( PrimRep(..) )
77 import TysPrim -- TYPES
81 import RdrName ( RdrName, mkPreludeQual )
82 import Var ( varUnique, Id )
83 import Name ( Name, OccName, Provenance(..),
84 NameSpace, tcName, clsName, varName, dataName,
85 getName, mkGlobalName, nameRdrName, systemProvenance
87 import RdrName ( rdrNameModule, rdrNameOcc, mkSrcQual )
88 import Class ( Class, classKey )
89 import TyCon ( tyConDataCons, TyCon )
90 import Type ( funTyCon )
92 import Unique -- *Key stuff
93 import UniqFM ( UniqFM, listToUFM, lookupWithDefaultUFM )
95 import Panic ( panic )
100 %************************************************************************
102 \subsection[builtinNameInfo]{Lookup built-in names}
104 %************************************************************************
106 We have two ``builtin name funs,'' one to look up @TyCons@ and
107 @Classes@, the other to look up values.
110 builtinNames :: Bag Name
114 unionManyBags (map getTyConNames wired_in_tycons)
117 , listToBag (map getName wired_in_ids)
120 , listToBag (map (getName . mkPrimitiveId) allThePrimOps)
123 , listToBag thinAirIdNames
125 -- Other names with magic keys
126 , listToBag knownKeyNames
132 getTyConNames :: TyCon -> Bag Name
134 = getName tycon `consBag`
135 listToBag (map getName (tyConDataCons tycon))
136 -- Synonyms return empty list of constructors
139 We let a lot of "non-standard" values be visible, so that we can make
140 sense of them in interface pragmas. It's cool, though they all have
141 "non-standard" names, so they won't get past the parser in user code.
144 %************************************************************************
146 \subsection{Wired in TyCons}
148 %************************************************************************
151 wired_in_tycons = [funTyCon] ++
154 unboxed_tuple_tycons ++
166 , foreignObjPrimTyCon
168 , mutableArrayPrimTyCon
169 , mutableByteArrayPrimTyCon
174 , stableNamePrimTyCon
181 tuple_tycons = unitTyCon : [tupleTyCon i | i <- [2..37] ]
182 unboxed_tuple_tycons = [unboxedTupleTyCon i | i <- [1..37] ]
198 %************************************************************************
200 \subsection{Wired in Ids}
202 %************************************************************************
206 = [ -- These error-y things are wired in because we don't yet have
207 -- a way to express in an interface file that the result type variable
208 -- is 'open'; that is can be unified with an unboxed type
210 -- [The interface file format now carry such information, but there's
211 -- no way yet of expressing at the definition site for these error-reporting
212 -- functions that they have an 'open' result type. -- sof 1/99]
216 , iRREFUT_PAT_ERROR_ID
217 , nON_EXHAUSTIVE_GUARDS_ERROR_ID
218 , nO_METHOD_BINDING_ERROR_ID
224 -- These three can't be defined in Haskell
232 %************************************************************************
234 \subsection{Thin air entities}
236 %************************************************************************
238 These are Ids that we need to reference in various parts of the
239 system, and we'd like to pull them out of thin air rather than pass
240 them around. We'd also like to have all the IdInfo available for each
241 one: i.e. everything that gets pulled out of the interface file.
243 The solution is to generate this map of global Ids after the
244 typechecker, and assign it to a global variable. Any subsequent
245 pass may refer to the map to pull Ids out. Any invalid
246 (i.e. pre-typechecker) access to the map will result in a panic.
250 = map mkKnownKeyGlobal
252 -- Needed for converting literals to Integers (used in tidyCoreExpr)
253 (varQual pREL_BASE SLIT("addr2Integer"), addr2IntegerIdKey)
256 , (varQual pREL_PACK SLIT("packCString#"), packCStringIdKey)
257 , (varQual pREL_PACK SLIT("unpackCString#"), unpackCStringIdKey)
258 , (varQual pREL_PACK SLIT("unpackNBytes#"), unpackCString2IdKey)
259 , (varQual pREL_PACK SLIT("unpackAppendCString#"), unpackCStringAppendIdKey)
260 , (varQual pREL_PACK SLIT("unpackFoldrCString#"), unpackCStringFoldrIdKey)
262 -- Folds; introduced by desugaring list comprehensions
263 , (varQual pREL_BASE SLIT("foldr"), foldrIdKey)
266 thinAirModules = [pREL_PACK] -- See notes with RnIfaces.findAndReadIface
268 noRepIntegerIds = [addr2IntegerId]
270 noRepStrIds = [unpackCString2Id, unpackCStringId]
272 addr2IntegerId = lookupThinAirId addr2IntegerIdKey
274 packStringForCId = lookupThinAirId packCStringIdKey
275 unpackCStringId = lookupThinAirId unpackCStringIdKey
276 unpackCString2Id = lookupThinAirId unpackCString2IdKey
277 unpackCStringAppendId = lookupThinAirId unpackCStringAppendIdKey
278 unpackCStringFoldrId = lookupThinAirId unpackCStringFoldrIdKey
280 foldrId = lookupThinAirId foldrIdKey
288 thinAirIdMapRef :: IORef (UniqFM Id)
289 thinAirIdMapRef = unsafePerformIO (newIORef (panic "thinAirIdMap: still empty"))
291 setThinAirIds :: [Id] -> IO ()
292 setThinAirIds thin_air_ids
293 = writeIORef thinAirIdMapRef the_map
295 the_map = listToUFM [(varUnique id, id) | id <- thin_air_ids]
297 thinAirIdMap :: UniqFM Id
298 thinAirIdMap = unsafePerformIO (readIORef thinAirIdMapRef)
299 -- Read it just once, the first time someone tugs on thinAirIdMap
301 lookupThinAirId :: Unique -> Id
302 lookupThinAirId uniq = lookupWithDefaultUFM thinAirIdMap
303 (panic "lookupThinAirId: no mapping") uniq
307 %************************************************************************
309 \subsection{Built-in keys}
311 %************************************************************************
313 Ids, Synonyms, Classes and ClassOps with builtin keys.
316 mkKnownKeyGlobal :: (RdrName, Unique) -> Name
317 mkKnownKeyGlobal (rdr_name, uniq)
318 = mkGlobalName uniq (rdrNameModule rdr_name) (rdrNameOcc rdr_name)
321 ioTyCon_NAME = mkKnownKeyGlobal (ioTyCon_RDR, ioTyConKey)
322 main_NAME = mkKnownKeyGlobal (main_RDR, mainKey)
324 -- Operations needed when compiling FFI decls
325 bindIO_NAME = mkKnownKeyGlobal (bindIO_RDR, bindIOIdKey)
326 deRefStablePtr_NAME = mkKnownKeyGlobal (deRefStablePtr_RDR, deRefStablePtrIdKey)
327 makeStablePtr_NAME = mkKnownKeyGlobal (makeStablePtr_RDR, makeStablePtrIdKey)
329 knownKeyNames :: [Name]
331 = [main_NAME, ioTyCon_NAME]
335 -- Type constructors (synonyms especially)
336 (orderingTyCon_RDR, orderingTyConKey)
337 , (rationalTyCon_RDR, rationalTyConKey)
338 , (ratioDataCon_RDR, ratioDataConKey)
339 , (ratioTyCon_RDR, ratioTyConKey)
340 , (byteArrayTyCon_RDR, byteArrayTyConKey)
341 , (mutableByteArrayTyCon_RDR, mutableByteArrayTyConKey)
342 , (foreignObjTyCon_RDR, foreignObjTyConKey)
343 , (stablePtrTyCon_RDR, stablePtrTyConKey)
344 , (stablePtrDataCon_RDR, stablePtrDataConKey)
346 -- Classes. *Must* include:
347 -- classes that are grabbed by key (e.g., eqClassKey)
348 -- classes in "Class.standardClassKeys" (quite a few)
349 , (eqClass_RDR, eqClassKey) -- mentioned, derivable
350 , (ordClass_RDR, ordClassKey) -- derivable
351 , (boundedClass_RDR, boundedClassKey) -- derivable
352 , (numClass_RDR, numClassKey) -- mentioned, numeric
353 , (enumClass_RDR, enumClassKey) -- derivable
354 , (monadClass_RDR, monadClassKey)
355 , (monadPlusClass_RDR, monadPlusClassKey)
356 , (functorClass_RDR, functorClassKey)
357 , (showClass_RDR, showClassKey) -- derivable
358 , (realClass_RDR, realClassKey) -- numeric
359 , (integralClass_RDR, integralClassKey) -- numeric
360 , (fractionalClass_RDR, fractionalClassKey) -- numeric
361 , (floatingClass_RDR, floatingClassKey) -- numeric
362 , (realFracClass_RDR, realFracClassKey) -- numeric
363 , (realFloatClass_RDR, realFloatClassKey) -- numeric
364 , (readClass_RDR, readClassKey) -- derivable
365 , (ixClass_RDR, ixClassKey) -- derivable (but it isn't Prelude.Ix; hmmm)
366 , (ccallableClass_RDR, cCallableClassKey) -- mentioned, ccallish
367 , (creturnableClass_RDR, cReturnableClassKey) -- mentioned, ccallish
370 , (fromInt_RDR, fromIntClassOpKey)
371 , (fromInteger_RDR, fromIntegerClassOpKey)
372 , (ge_RDR, geClassOpKey)
373 , (minus_RDR, minusClassOpKey)
374 , (enumFrom_RDR, enumFromClassOpKey)
375 , (enumFromThen_RDR, enumFromThenClassOpKey)
376 , (enumFromTo_RDR, enumFromToClassOpKey)
377 , (enumFromThenTo_RDR, enumFromThenToClassOpKey)
378 , (fromEnum_RDR, fromEnumClassOpKey)
379 , (toEnum_RDR, toEnumClassOpKey)
380 , (eq_RDR, eqClassOpKey)
381 , (thenM_RDR, thenMClassOpKey)
382 , (returnM_RDR, returnMClassOpKey)
383 , (failM_RDR, failMClassOpKey)
384 , (fromRational_RDR, fromRationalClassOpKey)
386 , (deRefStablePtr_RDR, deRefStablePtrIdKey)
387 , (makeStablePtr_RDR, makeStablePtrIdKey)
388 , (bindIO_RDR, bindIOIdKey)
390 , (map_RDR, mapIdKey)
391 , (append_RDR, appendIdKey)
394 , (concat_RDR, concatIdKey)
395 , (filter_RDR, filterIdKey)
396 , (zip_RDR, zipIdKey)
398 -- FFI primitive types that are not wired-in.
399 , (int8TyCon_RDR, int8TyConKey)
400 , (int16TyCon_RDR, int16TyConKey)
401 , (int32TyCon_RDR, int32TyConKey)
402 , (int64TyCon_RDR, int64TyConKey)
403 , (word8TyCon_RDR, word8TyConKey)
404 , (word16TyCon_RDR, word16TyConKey)
405 , (word32TyCon_RDR, word32TyConKey)
406 , (word64TyCon_RDR, word64TyConKey)
409 , (otherwiseId_RDR, otherwiseIdKey)
410 , (assert_RDR, assertIdKey)
414 ToDo: make it do the ``like'' part properly (as in 0.26 and before).
417 maybeCharLikeCon, maybeIntLikeCon :: DataCon -> Bool
418 maybeCharLikeCon con = getUnique con == charDataConKey
419 maybeIntLikeCon con = getUnique con == intDataConKey
422 %************************************************************************
424 \subsection{Commonly-used RdrNames}
426 %************************************************************************
428 These RdrNames are not really "built in", but some parts of the compiler
429 (notably the deriving mechanism) need to mention their names, and it's convenient
430 to write them all down in one place.
433 prelude_primop op = nameRdrName (getName (mkPrimitiveId op))
435 main_RDR = varQual mAIN SLIT("main")
436 otherwiseId_RDR = varQual pREL_BASE SLIT("otherwise")
438 intTyCon_RDR = nameRdrName (getName intTyCon)
439 ioTyCon_RDR = tcQual pREL_IO_BASE SLIT("IO")
440 ioDataCon_RDR = dataQual pREL_IO_BASE SLIT("IO")
441 bindIO_RDR = varQual pREL_IO_BASE SLIT("bindIO")
443 orderingTyCon_RDR = tcQual pREL_BASE SLIT("Ordering")
444 rationalTyCon_RDR = tcQual pREL_NUM SLIT("Rational")
445 ratioTyCon_RDR = tcQual pREL_NUM SLIT("Ratio")
446 ratioDataCon_RDR = dataQual pREL_NUM SLIT(":%")
448 byteArrayTyCon_RDR = tcQual pREL_ARR SLIT("ByteArray")
449 mutableByteArrayTyCon_RDR = tcQual pREL_ARR SLIT("MutableByteArray")
451 foreignObjTyCon_RDR = tcQual pREL_IO_BASE SLIT("ForeignObj")
452 stablePtrTyCon_RDR = tcQual pREL_STABLE SLIT("StablePtr")
453 stablePtrDataCon_RDR = dataQual pREL_STABLE SLIT("StablePtr")
454 deRefStablePtr_RDR = varQual pREL_STABLE SLIT("deRefStablePtr")
455 makeStablePtr_RDR = varQual pREL_STABLE SLIT("makeStablePtr")
457 eqClass_RDR = clsQual pREL_BASE SLIT("Eq")
458 ordClass_RDR = clsQual pREL_BASE SLIT("Ord")
459 boundedClass_RDR = clsQual pREL_BASE SLIT("Bounded")
460 numClass_RDR = clsQual pREL_BASE SLIT("Num")
461 enumClass_RDR = clsQual pREL_BASE SLIT("Enum")
462 monadClass_RDR = clsQual pREL_BASE SLIT("Monad")
463 monadPlusClass_RDR = clsQual pREL_BASE SLIT("MonadPlus")
464 functorClass_RDR = clsQual pREL_BASE SLIT("Functor")
465 showClass_RDR = clsQual pREL_BASE SLIT("Show")
466 realClass_RDR = clsQual pREL_NUM SLIT("Real")
467 integralClass_RDR = clsQual pREL_NUM SLIT("Integral")
468 fractionalClass_RDR = clsQual pREL_NUM SLIT("Fractional")
469 floatingClass_RDR = clsQual pREL_NUM SLIT("Floating")
470 realFracClass_RDR = clsQual pREL_NUM SLIT("RealFrac")
471 realFloatClass_RDR = clsQual pREL_NUM SLIT("RealFloat")
472 readClass_RDR = clsQual pREL_READ SLIT("Read")
473 ixClass_RDR = clsQual iX SLIT("Ix")
474 ccallableClass_RDR = clsQual pREL_GHC SLIT("CCallable")
475 creturnableClass_RDR = clsQual pREL_GHC SLIT("CReturnable")
477 fromInt_RDR = varQual pREL_BASE SLIT("fromInt")
478 fromInteger_RDR = varQual pREL_BASE SLIT("fromInteger")
479 minus_RDR = varQual pREL_BASE SLIT("-")
480 succ_RDR = varQual pREL_BASE SLIT("succ")
481 pred_RDR = varQual pREL_BASE SLIT("pred")
482 toEnum_RDR = varQual pREL_BASE SLIT("toEnum")
483 fromEnum_RDR = varQual pREL_BASE SLIT("fromEnum")
484 enumFrom_RDR = varQual pREL_BASE SLIT("enumFrom")
485 enumFromTo_RDR = varQual pREL_BASE SLIT("enumFromTo")
486 enumFromThen_RDR = varQual pREL_BASE SLIT("enumFromThen")
487 enumFromThenTo_RDR = varQual pREL_BASE SLIT("enumFromThenTo")
489 thenM_RDR = varQual pREL_BASE SLIT(">>=")
490 returnM_RDR = varQual pREL_BASE SLIT("return")
491 failM_RDR = varQual pREL_BASE SLIT("fail")
493 fromRational_RDR = varQual pREL_NUM SLIT("fromRational")
494 negate_RDR = varQual pREL_BASE SLIT("negate")
495 eq_RDR = varQual pREL_BASE SLIT("==")
496 ne_RDR = varQual pREL_BASE SLIT("/=")
497 le_RDR = varQual pREL_BASE SLIT("<=")
498 lt_RDR = varQual pREL_BASE SLIT("<")
499 ge_RDR = varQual pREL_BASE SLIT(">=")
500 gt_RDR = varQual pREL_BASE SLIT(">")
501 ltTag_RDR = dataQual pREL_BASE SLIT("LT")
502 eqTag_RDR = dataQual pREL_BASE SLIT("EQ")
503 gtTag_RDR = dataQual pREL_BASE SLIT("GT")
504 max_RDR = varQual pREL_BASE SLIT("max")
505 min_RDR = varQual pREL_BASE SLIT("min")
506 compare_RDR = varQual pREL_BASE SLIT("compare")
507 minBound_RDR = varQual pREL_BASE SLIT("minBound")
508 maxBound_RDR = varQual pREL_BASE SLIT("maxBound")
509 false_RDR = dataQual pREL_BASE SLIT("False")
510 true_RDR = dataQual pREL_BASE SLIT("True")
511 and_RDR = varQual pREL_BASE SLIT("&&")
512 not_RDR = varQual pREL_BASE SLIT("not")
513 compose_RDR = varQual pREL_BASE SLIT(".")
514 append_RDR = varQual pREL_BASE SLIT("++")
515 map_RDR = varQual pREL_BASE SLIT("map")
516 concat_RDR = varQual mONAD SLIT("concat")
517 filter_RDR = varQual mONAD SLIT("filter")
518 zip_RDR = varQual pREL_LIST SLIT("zip")
520 showList___RDR = varQual pREL_BASE SLIT("showList__")
521 showsPrec_RDR = varQual pREL_BASE SLIT("showsPrec")
522 showList_RDR = varQual pREL_BASE SLIT("showList")
523 showSpace_RDR = varQual pREL_BASE SLIT("showSpace")
524 showString_RDR = varQual pREL_BASE SLIT("showString")
525 showParen_RDR = varQual pREL_BASE SLIT("showParen")
527 range_RDR = varQual iX SLIT("range")
528 index_RDR = varQual iX SLIT("index")
529 inRange_RDR = varQual iX SLIT("inRange")
531 readsPrec_RDR = varQual pREL_READ SLIT("readsPrec")
532 readList_RDR = varQual pREL_READ SLIT("readList")
533 readParen_RDR = varQual pREL_READ SLIT("readParen")
534 lex_RDR = varQual pREL_READ SLIT("lex")
535 readList___RDR = varQual pREL_READ SLIT("readList__")
537 plus_RDR = varQual pREL_BASE SLIT("+")
538 times_RDR = varQual pREL_BASE SLIT("*")
539 mkInt_RDR = dataQual pREL_BASE SLIT("I#")
541 int8TyCon_RDR = tcQual iNT SLIT("Int8")
542 int16TyCon_RDR = tcQual iNT SLIT("Int16")
543 int32TyCon_RDR = tcQual iNT SLIT("Int32")
544 int64TyCon_RDR = tcQual pREL_ADDR SLIT("Int64")
546 word8TyCon_RDR = tcQual wORD SLIT("Word8")
547 word16TyCon_RDR = tcQual wORD SLIT("Word16")
548 word32TyCon_RDR = tcQual wORD SLIT("Word32")
549 word64TyCon_RDR = tcQual pREL_ADDR SLIT("Word64")
551 error_RDR = varQual pREL_ERR SLIT("error")
552 assert_RDR = varQual pREL_GHC SLIT("assert")
553 assertErr_RDR = varQual pREL_ERR SLIT("assertError")
555 eqH_Char_RDR = prelude_primop CharEqOp
556 ltH_Char_RDR = prelude_primop CharLtOp
557 eqH_Word_RDR = prelude_primop WordEqOp
558 ltH_Word_RDR = prelude_primop WordLtOp
559 eqH_Addr_RDR = prelude_primop AddrEqOp
560 ltH_Addr_RDR = prelude_primop AddrLtOp
561 eqH_Float_RDR = prelude_primop FloatEqOp
562 ltH_Float_RDR = prelude_primop FloatLtOp
563 eqH_Double_RDR = prelude_primop DoubleEqOp
564 ltH_Double_RDR = prelude_primop DoubleLtOp
565 eqH_Int_RDR = prelude_primop IntEqOp
566 ltH_Int_RDR = prelude_primop IntLtOp
567 geH_RDR = prelude_primop IntGeOp
568 leH_RDR = prelude_primop IntLeOp
569 minusH_RDR = prelude_primop IntSubOp
570 tagToEnumH_RDR = prelude_primop TagToEnumOp
572 getTag_RDR = varQual pREL_GHC SLIT("getTag#")
576 mkTupConRdrName :: Int -> RdrName
577 mkTupConRdrName arity = case mkTupNameStr arity of
578 (mod, occ) -> dataQual mod occ
580 mkUbxTupConRdrName :: Int -> RdrName
581 mkUbxTupConRdrName arity = case mkUbxTupNameStr arity of
582 (mod, occ) -> dataQual mod occ
586 %************************************************************************
588 \subsection[Class-std-groups]{Standard groups of Prelude classes}
590 %************************************************************************
592 @derivableClassKeys@ is also used in checking \tr{deriving} constructs
595 @derivingOccurrences@ maps a class name to a list of the (qualified) occurrences
596 that will be mentioned by the derived code for the class when it is later generated.
597 We don't need to put in things that are WiredIn (because they are already mapped to their
598 correct name by the @NameSupply@. The class itself, and all its class ops, is
599 already flagged as an occurrence so we don't need to mention that either.
601 @derivingOccurrences@ has an item for every derivable class, even if that item is empty,
602 because we treat lookup failure as indicating that the class is illegal in a deriving clause.
605 derivingOccurrences :: UniqFM [RdrName]
606 derivingOccurrences = listToUFM deriving_occ_info
608 derivableClassKeys = map fst deriving_occ_info
611 = [ (eqClassKey, [intTyCon_RDR, and_RDR, not_RDR])
612 , (ordClassKey, [intTyCon_RDR, compose_RDR, eqTag_RDR])
613 -- EQ (from Ordering) is needed to force in the constructors
614 -- as well as the type constructor.
615 , (enumClassKey, [intTyCon_RDR, eq_RDR, ge_RDR, and_RDR, map_RDR, plus_RDR, showsPrec_RDR, append_RDR])
616 -- The last two Enum deps are only used to produce better
617 -- error msgs for derived toEnum methods.
618 , (boundedClassKey, [intTyCon_RDR])
619 , (showClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, compose_RDR, showString_RDR,
620 showParen_RDR, showSpace_RDR, showList___RDR])
621 , (readClassKey, [intTyCon_RDR, numClass_RDR, ordClass_RDR, append_RDR,
622 lex_RDR, readParen_RDR, readList___RDR, thenM_RDR])
623 -- returnM (and the rest of the Monad class decl)
624 -- will be forced in as result of depending
625 -- on thenM. -- SOF 1/99
626 , (ixClassKey, [intTyCon_RDR, numClass_RDR, and_RDR, map_RDR, enumFromTo_RDR,
627 returnM_RDR, failM_RDR])
628 -- the last two are needed to force returnM, thenM and failM
629 -- in before typechecking the list(monad) comprehension
630 -- generated for derived Ix instances (range method)
631 -- of single constructor types. -- SOF 8/97
633 -- intTyCon: Practically any deriving needs Int, either for index calculations,
635 -- ordClass: really it's the methods that are actually used.
636 -- numClass: for Int literals
640 NOTE: @Eq@ and @Text@ do need to appear in @standardClasses@
641 even though every numeric class has these two as a superclass,
642 because the list of ambiguous dictionaries hasn't been simplified.
645 isCcallishClass, isCreturnableClass, isNoDictClass,
646 isNumericClass, isStandardClass :: Class -> Bool
648 isNumericClass clas = classKey clas `is_elem` numericClassKeys
649 isStandardClass clas = classKey clas `is_elem` standardClassKeys
650 isCcallishClass clas = classKey clas `is_elem` cCallishClassKeys
651 isCreturnableClass clas = classKey clas == cReturnableClassKey
652 isNoDictClass clas = classKey clas `is_elem` noDictClassKeys
653 is_elem = isIn "is_X_Class"
665 -- the strictness analyser needs to know about numeric types
666 -- (see SaAbsInt.lhs)
676 needsDataDeclCtxtClassKeys = -- see comments in TcDeriv
682 , cReturnableClassKey
685 -- Renamer always imports these data decls replete with constructors
686 -- so that desugarer can always see their constructors. Ugh!
691 , mutableByteArrayTyConKey
705 = derivableClassKeys ++ numericClassKeys ++ cCallishClassKeys
707 -- We have to have "CCallable" and "CReturnable" in the standard
708 -- classes, so that if you go...
710 -- _ccall_ foo ... 93{-numeric literal-} ...
712 -- ... it can do The Right Thing on the 93.
714 noDictClassKeys -- These classes are used only for type annotations;
715 -- they are not implemented by dictionaries, ever.
720 %************************************************************************
722 \subsection{Local helpers}
724 %************************************************************************
727 varQual = mkPreludeQual varName
728 dataQual = mkPreludeQual dataName
729 tcQual = mkPreludeQual tcName
730 clsQual = mkPreludeQual clsName