resurrected -fdicts-strict, off by default
[ghc.git] / compiler / basicTypes / OccName.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5
6 \begin{code}
7 -- |
8 -- #name_types#
9 -- GHC uses several kinds of name internally:
10 --
11 -- * 'OccName.OccName' represents names as strings with just a little more information:
12 --   the \"namespace\" that the name came from, e.g. the namespace of value, type constructors or
13 --   data constructors
14 --
15 -- * 'RdrName.RdrName': see "RdrName#name_types"
16 --
17 -- * 'Name.Name': see "Name#name_types"
18 --
19 -- * 'Id.Id': see "Id#name_types"
20 --
21 -- * 'Var.Var': see "Var#name_types"
22
23 {-# OPTIONS -fno-warn-tabs #-}
24 -- The above warning supression flag is a temporary kludge.
25 -- While working on this module you are encouraged to remove it and
26 -- detab the module (please do the detabbing in a separate patch). See
27 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#TabsvsSpaces
28 -- for details
29
30 module OccName (
31         -- * The 'NameSpace' type
32         NameSpace, -- Abstract
33         
34         -- ** Construction
35         -- $real_vs_source_data_constructors
36         tcName, clsName, tcClsName, dataName, varName, 
37         tvName, srcDataName,
38
39         -- ** Pretty Printing
40         pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
41
42         -- * The 'OccName' type
43         OccName,        -- Abstract, instance of Outputable
44         pprOccName, 
45
46         -- ** Construction      
47         mkOccName, mkOccNameFS, 
48         mkVarOcc, mkVarOccFS,
49         mkDataOcc, mkDataOccFS,
50         mkTyVarOcc, mkTyVarOccFS,
51         mkTcOcc, mkTcOccFS,
52         mkClsOcc, mkClsOccFS,
53         mkDFunOcc,
54         mkTupleOcc, 
55         setOccNameSpace,
56         demoteOccName,
57         HasOccName(..),
58
59         -- ** Derived 'OccName's
60         isDerivedOccName,
61         mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, 
62         mkGenDefMethodOcc, 
63         mkDerivedTyConOcc, mkNewTyCoOcc, mkClassOpAuxOcc,
64         mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
65         mkClassDataConOcc, mkDictOcc, mkIPOcc, 
66         mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
67         mkGenD, mkGenR, mkGen1R, mkGenRCo, mkGenC, mkGenS,
68         mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc,
69         mkSuperDictSelOcc, mkLocalOcc, mkMethodOcc, mkInstTyTcOcc,
70         mkInstTyCoOcc, mkEqPredCoOcc,
71         mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
72         mkPDataTyConOcc,  mkPDataDataConOcc,
73         mkPDatasTyConOcc, mkPDatasDataConOcc,
74         mkPReprTyConOcc, 
75         mkPADFunOcc,
76
77         -- ** Deconstruction
78         occNameFS, occNameString, occNameSpace, 
79
80         isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
81         parenSymOcc, startsWithUnderscore, 
82         
83         isTcClsNameSpace, isTvNameSpace, isDataConNameSpace, isVarNameSpace, isValNameSpace,
84
85         isTupleOcc_maybe,
86
87         -- * The 'OccEnv' type
88         OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
89         lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
90         occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
91         extendOccEnv_Acc, filterOccEnv, delListFromOccEnv, delFromOccEnv,
92
93         -- * The 'OccSet' type
94         OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet, 
95         extendOccSetList,
96         unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts, 
97         foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
98                   
99         -- * Tidying up
100         TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
101
102         -- * Lexical characteristics of Haskell names
103         isLexCon, isLexVar, isLexId, isLexSym,
104         isLexConId, isLexConSym, isLexVarId, isLexVarSym,
105         startsVarSym, startsVarId, startsConSym, startsConId
106     ) where
107
108 #include "Typeable.h"
109
110 import Util
111 import Unique
112 import BasicTypes
113 import DynFlags
114 import UniqFM
115 import UniqSet
116 import FastString
117 import Outputable
118 import Binary
119 import Data.Char
120 import Data.Data
121 \end{code}
122
123 %************************************************************************
124 %*                                                                      *
125 \subsection{Name space}
126 %*                                                                      *
127 %************************************************************************
128
129 \begin{code}
130 data NameSpace = VarName        -- Variables, including "real" data constructors
131                | DataName       -- "Source" data constructors 
132                | TvName         -- Type variables
133                | TcClsName      -- Type constructors and classes; Haskell has them
134                                 -- in the same name space for now.
135                deriving( Eq, Ord )
136    {-! derive: Binary !-}
137
138 -- Note [Data Constructors]  
139 -- see also: Note [Data Constructor Naming] in DataCon.lhs
140 --
141 -- $real_vs_source_data_constructors
142 -- There are two forms of data constructor:
143 --
144 --      [Source data constructors] The data constructors mentioned in Haskell source code
145 --
146 --      [Real data constructors] The data constructors of the representation type, which may not be the same as the source type
147 --
148 -- For example:
149 --
150 -- > data T = T !(Int, Int)
151 --
152 -- The source datacon has type @(Int, Int) -> T@
153 -- The real   datacon has type @Int -> Int -> T@
154 --
155 -- GHC chooses a representation based on the strictness etc.
156
157 tcName, clsName, tcClsName :: NameSpace
158 dataName, srcDataName      :: NameSpace
159 tvName, varName            :: NameSpace
160
161 -- Though type constructors and classes are in the same name space now,
162 -- the NameSpace type is abstract, so we can easily separate them later
163 tcName    = TcClsName           -- Type constructors
164 clsName   = TcClsName           -- Classes
165 tcClsName = TcClsName           -- Not sure which!
166
167 dataName    = DataName
168 srcDataName = DataName  -- Haskell-source data constructors should be
169                         -- in the Data name space
170
171 tvName      = TvName
172 varName     = VarName
173
174 isDataConNameSpace :: NameSpace -> Bool
175 isDataConNameSpace DataName = True
176 isDataConNameSpace _        = False
177
178 isTcClsNameSpace :: NameSpace -> Bool
179 isTcClsNameSpace TcClsName = True
180 isTcClsNameSpace _         = False
181
182 isTvNameSpace :: NameSpace -> Bool
183 isTvNameSpace TvName = True
184 isTvNameSpace _      = False
185
186 isVarNameSpace :: NameSpace -> Bool     -- Variables or type variables, but not constructors
187 isVarNameSpace TvName  = True
188 isVarNameSpace VarName = True
189 isVarNameSpace _       = False
190
191 isValNameSpace :: NameSpace -> Bool
192 isValNameSpace DataName = True
193 isValNameSpace VarName  = True
194 isValNameSpace _        = False
195
196 pprNameSpace :: NameSpace -> SDoc
197 pprNameSpace DataName  = ptext (sLit "data constructor")
198 pprNameSpace VarName   = ptext (sLit "variable")
199 pprNameSpace TvName    = ptext (sLit "type variable")
200 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
201
202 pprNonVarNameSpace :: NameSpace -> SDoc
203 pprNonVarNameSpace VarName = empty
204 pprNonVarNameSpace ns = pprNameSpace ns
205
206 pprNameSpaceBrief :: NameSpace -> SDoc
207 pprNameSpaceBrief DataName  = char 'd'
208 pprNameSpaceBrief VarName   = char 'v'
209 pprNameSpaceBrief TvName    = ptext (sLit "tv")
210 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
211
212 -- demoteNameSpace lowers the NameSpace if possible.  We can not know
213 -- in advance, since a TvName can appear in an HsTyVar.
214 -- See Note [Demotion] in RnEnv
215 demoteNameSpace :: NameSpace -> Maybe NameSpace
216 demoteNameSpace VarName = Nothing
217 demoteNameSpace DataName = Nothing
218 demoteNameSpace TvName = Nothing
219 demoteNameSpace TcClsName = Just DataName
220 \end{code}
221
222
223 %************************************************************************
224 %*                                                                      *
225 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
226 %*                                                                      *
227 %************************************************************************
228
229 \begin{code}
230 data OccName = OccName 
231     { occNameSpace  :: !NameSpace
232     , occNameFS     :: !FastString
233     }
234     deriving Typeable
235 \end{code}
236
237
238 \begin{code}
239 instance Eq OccName where
240     (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
241
242 instance Ord OccName where
243         -- Compares lexicographically, *not* by Unique of the string
244     compare (OccName sp1 s1) (OccName sp2 s2) 
245         = (s1  `compare` s2) `thenCmp` (sp1 `compare` sp2)
246
247 instance Data OccName where
248   -- don't traverse?
249   toConstr _   = abstractConstr "OccName"
250   gunfold _ _  = error "gunfold"
251   dataTypeOf _ = mkNoRepType "OccName"
252 \end{code}
253
254
255 %************************************************************************
256 %*                                                                      *
257 \subsection{Printing}
258 %*                                                                      *
259 %************************************************************************
260  
261 \begin{code}
262 instance Outputable OccName where
263     ppr = pprOccName
264
265 pprOccName :: OccName -> SDoc
266 pprOccName (OccName sp occ) 
267   = getPprStyle $ \ sty ->
268     if codeStyle sty 
269     then ztext (zEncodeFS occ)
270     else pp_occ <> pp_debug sty
271   where
272     pp_debug sty | debugStyle sty = braces (pprNameSpaceBrief sp)
273                  | otherwise      = empty
274
275     pp_occ = sdocWithDynFlags $ \dflags ->
276              if gopt Opt_SuppressUniques dflags
277              then text (strip_th_unique (unpackFS occ))
278              else ftext occ
279
280         -- See Note [Suppressing uniques in OccNames]
281     strip_th_unique ('[' : c : _) | isAlphaNum c = []
282     strip_th_unique (c : cs) = c : strip_th_unique cs
283     strip_th_unique []       = []
284 \end{code}
285
286 Note [Suppressing uniques in OccNames]
287 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
288 This is a hack to de-wobblify the OccNames that contain uniques from
289 Template Haskell that have been turned into a string in the OccName.
290 See Note [Unique OccNames from Template Haskell] in Convert.hs
291
292 %************************************************************************
293 %*                                                                      *
294 \subsection{Construction}
295 %*                                                                      *
296 %************************************************************************
297
298 \begin{code}
299 mkOccName :: NameSpace -> String -> OccName
300 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
301
302 mkOccNameFS :: NameSpace -> FastString -> OccName
303 mkOccNameFS occ_sp fs = OccName occ_sp fs
304
305 mkVarOcc :: String -> OccName
306 mkVarOcc s = mkOccName varName s
307
308 mkVarOccFS :: FastString -> OccName
309 mkVarOccFS fs = mkOccNameFS varName fs
310
311 mkDataOcc :: String -> OccName
312 mkDataOcc = mkOccName dataName
313
314 mkDataOccFS :: FastString -> OccName
315 mkDataOccFS = mkOccNameFS dataName
316
317 mkTyVarOcc :: String -> OccName
318 mkTyVarOcc = mkOccName tvName
319
320 mkTyVarOccFS :: FastString -> OccName
321 mkTyVarOccFS fs = mkOccNameFS tvName fs
322
323 mkTcOcc :: String -> OccName
324 mkTcOcc = mkOccName tcName
325
326 mkTcOccFS :: FastString -> OccName
327 mkTcOccFS = mkOccNameFS tcName
328
329 mkClsOcc :: String -> OccName
330 mkClsOcc = mkOccName clsName
331
332 mkClsOccFS :: FastString -> OccName
333 mkClsOccFS = mkOccNameFS clsName
334
335 -- demoteOccName lowers the Namespace of OccName.
336 -- see Note [Demotion]
337 demoteOccName :: OccName -> Maybe OccName
338 demoteOccName (OccName space name) = do
339   space' <- demoteNameSpace space
340   return $ OccName space' name
341
342 {- | Other names in the compiler add aditional information to an OccName.
343 This class provides a consistent way to access the underlying OccName. -}
344 class HasOccName name where
345   occName :: name -> OccName
346 \end{code}
347
348
349 %************************************************************************
350 %*                                                                      *
351                 Environments
352 %*                                                                      *
353 %************************************************************************
354
355 OccEnvs are used mainly for the envts in ModIfaces.
356
357 Note [The Unique of an OccName]
358 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
359 They are efficient, because FastStrings have unique Int# keys.  We assume
360 this key is less than 2^24, and indeed FastStrings are allocated keys 
361 sequentially starting at 0.
362
363 So we can make a Unique using
364         mkUnique ns key  :: Unique
365 where 'ns' is a Char representing the name space.  This in turn makes it
366 easy to build an OccEnv.
367
368 \begin{code}
369 instance Uniquable OccName where
370       -- See Note [The Unique of an OccName]
371   getUnique (OccName VarName   fs) = mkVarOccUnique  fs
372   getUnique (OccName DataName  fs) = mkDataOccUnique fs
373   getUnique (OccName TvName    fs) = mkTvOccUnique   fs
374   getUnique (OccName TcClsName fs) = mkTcOccUnique   fs
375
376 newtype OccEnv a = A (UniqFM a)
377
378 emptyOccEnv :: OccEnv a
379 unitOccEnv  :: OccName -> a -> OccEnv a
380 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
381 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
382 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
383 mkOccEnv     :: [(OccName,a)] -> OccEnv a
384 mkOccEnv_C   :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
385 elemOccEnv   :: OccName -> OccEnv a -> Bool
386 foldOccEnv   :: (a -> b -> b) -> b -> OccEnv a -> b
387 occEnvElts   :: OccEnv a -> [a]
388 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
389 extendOccEnv_Acc :: (a->b->b) -> (a->b) -> OccEnv b -> OccName -> a -> OccEnv b
390 plusOccEnv     :: OccEnv a -> OccEnv a -> OccEnv a
391 plusOccEnv_C   :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
392 mapOccEnv      :: (a->b) -> OccEnv a -> OccEnv b
393 delFromOccEnv      :: OccEnv a -> OccName -> OccEnv a
394 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
395 filterOccEnv       :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
396
397 emptyOccEnv      = A emptyUFM
398 unitOccEnv x y = A $ unitUFM x y 
399 extendOccEnv (A x) y z = A $ addToUFM x y z
400 extendOccEnvList (A x) l = A $ addListToUFM x l
401 lookupOccEnv (A x) y = lookupUFM x y
402 mkOccEnv     l    = A $ listToUFM l
403 elemOccEnv x (A y)       = elemUFM x y
404 foldOccEnv a b (A c)     = foldUFM a b c 
405 occEnvElts (A x)         = eltsUFM x
406 plusOccEnv (A x) (A y)   = A $ plusUFM x y 
407 plusOccEnv_C f (A x) (A y)       = A $ plusUFM_C f x y 
408 extendOccEnv_C f (A x) y z   = A $ addToUFM_C f x y z
409 extendOccEnv_Acc f g (A x) y z   = A $ addToUFM_Acc f g x y z
410 mapOccEnv f (A x)        = A $ mapUFM f x
411 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
412 delFromOccEnv (A x) y    = A $ delFromUFM x y
413 delListFromOccEnv (A x) y  = A $ delListFromUFM x y
414 filterOccEnv x (A y)       = A $ filterUFM x y
415
416 instance Outputable a => Outputable (OccEnv a) where
417     ppr (A x) = ppr x
418
419 type OccSet = UniqSet OccName
420
421 emptyOccSet       :: OccSet
422 unitOccSet        :: OccName -> OccSet
423 mkOccSet          :: [OccName] -> OccSet
424 extendOccSet      :: OccSet -> OccName -> OccSet
425 extendOccSetList  :: OccSet -> [OccName] -> OccSet
426 unionOccSets      :: OccSet -> OccSet -> OccSet
427 unionManyOccSets  :: [OccSet] -> OccSet
428 minusOccSet       :: OccSet -> OccSet -> OccSet
429 elemOccSet        :: OccName -> OccSet -> Bool
430 occSetElts        :: OccSet -> [OccName]
431 foldOccSet        :: (OccName -> b -> b) -> b -> OccSet -> b
432 isEmptyOccSet     :: OccSet -> Bool
433 intersectOccSet   :: OccSet -> OccSet -> OccSet
434 intersectsOccSet  :: OccSet -> OccSet -> Bool
435
436 emptyOccSet       = emptyUniqSet
437 unitOccSet        = unitUniqSet
438 mkOccSet          = mkUniqSet
439 extendOccSet      = addOneToUniqSet
440 extendOccSetList  = addListToUniqSet
441 unionOccSets      = unionUniqSets
442 unionManyOccSets  = unionManyUniqSets
443 minusOccSet       = minusUniqSet
444 elemOccSet        = elementOfUniqSet
445 occSetElts        = uniqSetToList
446 foldOccSet        = foldUniqSet
447 isEmptyOccSet     = isEmptyUniqSet
448 intersectOccSet   = intersectUniqSets
449 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
450 \end{code}
451
452
453 %************************************************************************
454 %*                                                                      *
455 \subsection{Predicates and taking them apart}
456 %*                                                                      *
457 %************************************************************************
458
459 \begin{code}
460 occNameString :: OccName -> String
461 occNameString (OccName _ s) = unpackFS s
462
463 setOccNameSpace :: NameSpace -> OccName -> OccName
464 setOccNameSpace sp (OccName _ occ) = OccName sp occ
465
466 isVarOcc, isTvOcc, isTcOcc, isDataOcc :: OccName -> Bool
467
468 isVarOcc (OccName VarName _) = True
469 isVarOcc _                   = False
470
471 isTvOcc (OccName TvName _) = True
472 isTvOcc _                  = False
473
474 isTcOcc (OccName TcClsName _) = True
475 isTcOcc _                     = False
476
477 -- | /Value/ 'OccNames's are those that are either in 
478 -- the variable or data constructor namespaces
479 isValOcc :: OccName -> Bool
480 isValOcc (OccName VarName  _) = True
481 isValOcc (OccName DataName _) = True
482 isValOcc _                    = False
483
484 isDataOcc (OccName DataName _) = True
485 isDataOcc _                    = False
486
487 -- | Test if the 'OccName' is a data constructor that starts with
488 -- a symbol (e.g. @:@, or @[]@)
489 isDataSymOcc :: OccName -> Bool
490 isDataSymOcc (OccName DataName s) = isLexConSym s
491 isDataSymOcc _                    = False
492 -- Pretty inefficient!
493
494 -- | Test if the 'OccName' is that for any operator (whether 
495 -- it is a data constructor or variable or whatever)
496 isSymOcc :: OccName -> Bool
497 isSymOcc (OccName DataName s)  = isLexConSym s
498 isSymOcc (OccName TcClsName s) = isLexConSym s || isLexVarSym s
499 isSymOcc (OccName VarName s)   = isLexSym s
500 isSymOcc (OccName TvName s)    = isLexSym s
501 -- Pretty inefficient!
502
503 parenSymOcc :: OccName -> SDoc -> SDoc
504 -- ^ Wrap parens around an operator
505 parenSymOcc occ doc | isSymOcc occ = parens doc
506                     | otherwise    = doc
507 \end{code}
508
509
510 \begin{code}
511 startsWithUnderscore :: OccName -> Bool
512 -- ^ Haskell 98 encourages compilers to suppress warnings about unsed
513 -- names in a pattern if they start with @_@: this implements that test
514 startsWithUnderscore occ = case occNameString occ of
515                              ('_' : _) -> True
516                              _other    -> False
517 \end{code}
518
519
520 %************************************************************************
521 %*                                                                      *
522 \subsection{Making system names}
523 %*                                                                      *
524 %************************************************************************
525
526 Here's our convention for splitting up the interface file name space:
527
528    d...         dictionary identifiers
529                 (local variables, so no name-clash worries)
530
531 All of these other OccNames contain a mixture of alphabetic
532 and symbolic characters, and hence cannot possibly clash with
533 a user-written type or function name
534
535    $f...        Dict-fun identifiers (from inst decls)
536    $dmop        Default method for 'op'
537    $pnC         n'th superclass selector for class C
538    $wf          Worker for functtoin 'f'
539    $sf..        Specialised version of f
540    T:C          Tycon for dictionary for class C
541    D:C          Data constructor for dictionary for class C
542    NTCo:T       Coercion connecting newtype T with its representation type
543    TFCo:R       Coercion connecting a data family to its respresentation type R
544
545 In encoded form these appear as Zdfxxx etc
546
547         :...            keywords (export:, letrec: etc.)
548 --- I THINK THIS IS WRONG!
549
550 This knowledge is encoded in the following functions.
551
552 @mk_deriv@ generates an @OccName@ from the prefix and a string.
553 NB: The string must already be encoded!
554
555 \begin{code}
556 mk_deriv :: NameSpace 
557          -> String              -- Distinguishes one sort of derived name from another
558          -> String
559          -> OccName
560
561 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
562
563 isDerivedOccName :: OccName -> Bool
564 isDerivedOccName occ = 
565    case occNameString occ of
566      '$':c:_ | isAlphaNum c -> True
567      ':':c:_ | isAlphaNum c -> True
568      _other                 -> False
569 \end{code}
570
571 \begin{code}
572 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, 
573         mkGenDefMethodOcc, mkDerivedTyConOcc, mkClassDataConOcc, mkDictOcc,
574         mkIPOcc, mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
575         mkGenD, mkGenR, mkGen1R, mkGenRCo,
576         mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
577         mkInstTyCoOcc, mkEqPredCoOcc, mkClassOpAuxOcc,
578         mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc
579    :: OccName -> OccName
580
581 -- These derived variables have a prefix that no Haskell value could have
582 mkDataConWrapperOcc = mk_simple_deriv varName  "$W"
583 mkWorkerOcc         = mk_simple_deriv varName  "$w"
584 mkDefaultMethodOcc  = mk_simple_deriv varName  "$dm"
585 mkGenDefMethodOcc   = mk_simple_deriv varName  "$gdm"
586 mkClassOpAuxOcc     = mk_simple_deriv varName  "$c"
587 mkDerivedTyConOcc   = mk_simple_deriv tcName   ":"      -- The : prefix makes sure it classifies as a tycon/datacon
588 mkClassDataConOcc   = mk_simple_deriv dataName "D:"     -- We go straight to the "real" data con
589                                                         -- for datacons from classes
590 mkDictOcc           = mk_simple_deriv varName  "$d"
591 mkIPOcc             = mk_simple_deriv varName  "$i"
592 mkSpecOcc           = mk_simple_deriv varName  "$s"
593 mkForeignExportOcc  = mk_simple_deriv varName  "$f"
594 mkNewTyCoOcc        = mk_simple_deriv tcName   "NTCo:"  -- Coercion for newtypes
595 mkInstTyCoOcc       = mk_simple_deriv tcName   "TFCo:"   -- Coercion for type functions
596 mkEqPredCoOcc       = mk_simple_deriv tcName   "$co"
597
598 -- used in derived instances
599 mkCon2TagOcc        = mk_simple_deriv varName  "$con2tag_"
600 mkTag2ConOcc        = mk_simple_deriv varName  "$tag2con_"
601 mkMaxTagOcc         = mk_simple_deriv varName  "$maxtag_"
602
603 -- Generic derivable classes (old)
604 mkGenOcc1           = mk_simple_deriv varName  "$gfrom"
605 mkGenOcc2           = mk_simple_deriv varName  "$gto" 
606
607 -- Generic deriving mechanism (new)
608 mkGenD         = mk_simple_deriv tcName "D1"
609
610 mkGenC :: OccName -> Int -> OccName
611 mkGenC occ m   = mk_deriv tcName ("C1_" ++ show m) (occNameString occ)
612
613 mkGenS :: OccName -> Int -> Int -> OccName
614 mkGenS occ m n = mk_deriv tcName ("S1_" ++ show m ++ "_" ++ show n)
615                    (occNameString occ)
616
617 mkGenR   = mk_simple_deriv tcName "Rep_"
618 mkGen1R  = mk_simple_deriv tcName "Rep1_"
619 mkGenRCo = mk_simple_deriv tcName "CoRep_"
620
621 -- data T = MkT ... deriving( Data ) needs definitions for 
622 --      $tT   :: Data.Generics.Basics.DataType
623 --      $cMkT :: Data.Generics.Basics.Constr
624 mkDataTOcc = mk_simple_deriv varName  "$t"
625 mkDataCOcc = mk_simple_deriv varName  "$c"
626
627 -- Vectorisation
628 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
629  mkPADFunOcc,      mkPReprTyConOcc,
630  mkPDataTyConOcc,  mkPDataDataConOcc,
631  mkPDatasTyConOcc, mkPDatasDataConOcc
632   :: Maybe String -> OccName -> OccName
633 mkVectOcc          = mk_simple_deriv_with varName  "$v"
634 mkVectTyConOcc     = mk_simple_deriv_with tcName   "V:"
635 mkVectDataConOcc   = mk_simple_deriv_with dataName "VD:"
636 mkVectIsoOcc       = mk_simple_deriv_with varName  "$vi"
637 mkPADFunOcc        = mk_simple_deriv_with varName  "$pa"
638 mkPReprTyConOcc    = mk_simple_deriv_with tcName   "VR:"
639 mkPDataTyConOcc    = mk_simple_deriv_with tcName   "VP:"
640 mkPDatasTyConOcc   = mk_simple_deriv_with tcName   "VPs:"
641 mkPDataDataConOcc  = mk_simple_deriv_with dataName "VPD:"
642 mkPDatasDataConOcc = mk_simple_deriv_with dataName "VPDs:"
643
644 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
645 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
646
647 mk_simple_deriv_with :: NameSpace -> String -> Maybe String -> OccName -> OccName
648 mk_simple_deriv_with sp px Nothing     occ = mk_deriv sp px                  (occNameString occ)
649 mk_simple_deriv_with sp px (Just with) occ = mk_deriv sp (px ++ with ++ "_") (occNameString occ)
650
651 -- Data constructor workers are made by setting the name space
652 -- of the data constructor OccName (which should be a DataName)
653 -- to VarName
654 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ 
655 \end{code}
656
657 \begin{code}
658 mkSuperDictSelOcc :: Int        -- ^ Index of superclass, e.g. 3
659                   -> OccName    -- ^ Class, e.g. @Ord@
660                   -> OccName    -- ^ Derived 'Occname', e.g. @$p3Ord@
661 mkSuperDictSelOcc index cls_tc_occ
662   = mk_deriv varName "$p" (show index ++ occNameString cls_tc_occ)
663
664 mkLocalOcc :: Unique            -- ^ Unique to combine with the 'OccName'
665            -> OccName           -- ^ Local name, e.g. @sat@
666            -> OccName           -- ^ Nice unique version, e.g. @$L23sat@
667 mkLocalOcc uniq occ
668    = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
669         -- The Unique might print with characters 
670         -- that need encoding (e.g. 'z'!)
671 \end{code}
672
673 \begin{code}
674 -- | Derive a name for the representation type constructor of a
675 -- @data@\/@newtype@ instance.
676 mkInstTyTcOcc :: String                 -- ^ Family name, e.g. @Map@
677               -> OccSet                 -- ^ avoid these Occs
678               -> OccName                -- ^ @R:Map@
679 mkInstTyTcOcc str set =
680   chooseUniqueOcc tcName ('R' : ':' : str) set
681 \end{code}
682
683 \begin{code}
684 mkDFunOcc :: String             -- ^ Typically the class and type glommed together e.g. @OrdMaybe@.
685                                 -- Only used in debug mode, for extra clarity
686           -> Bool               -- ^ Is this a hs-boot instance DFun?
687           -> OccSet             -- ^ avoid these Occs
688           -> OccName            -- ^ E.g. @$f3OrdMaybe@
689
690 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
691 -- thing when we compile the mother module. Reason: we don't know exactly
692 -- what the  mother module will call it.
693
694 mkDFunOcc info_str is_boot set
695   = chooseUniqueOcc VarName (prefix ++ info_str) set
696   where
697     prefix | is_boot   = "$fx"
698            | otherwise = "$f"
699 \end{code}
700
701 Sometimes we need to pick an OccName that has not already been used,
702 given a set of in-use OccNames.
703
704 \begin{code}
705 chooseUniqueOcc :: NameSpace -> String -> OccSet -> OccName
706 chooseUniqueOcc ns str set = loop (mkOccName ns str) (0::Int)
707   where
708   loop occ n
709    | occ `elemOccSet` set = loop (mkOccName ns (str ++ show n)) (n+1)
710    | otherwise            = occ
711 \end{code}
712
713 We used to add a '$m' to indicate a method, but that gives rise to bad
714 error messages from the type checker when we print the function name or pattern
715 of an instance-decl binding.  Why? Because the binding is zapped
716 to use the method name in place of the selector name.
717 (See TcClassDcl.tcMethodBind)
718
719 The way it is now, -ddump-xx output may look confusing, but
720 you can always say -dppr-debug to get the uniques.
721
722 However, we *do* have to zap the first character to be lower case,
723 because overloaded constructors (blarg) generate methods too.
724 And convert to VarName space
725
726 e.g. a call to constructor MkFoo where
727         data (Ord a) => Foo a = MkFoo a
728
729 If this is necessary, we do it by prefixing '$m'.  These 
730 guys never show up in error messages.  What a hack.
731
732 \begin{code}
733 mkMethodOcc :: OccName -> OccName
734 mkMethodOcc occ@(OccName VarName _) = occ
735 mkMethodOcc occ                     = mk_simple_deriv varName "$m" occ
736 \end{code}
737
738
739 %************************************************************************
740 %*                                                                      *
741 \subsection{Tidying them up}
742 %*                                                                      *
743 %************************************************************************
744
745 Before we print chunks of code we like to rename it so that
746 we don't have to print lots of silly uniques in it.  But we mustn't
747 accidentally introduce name clashes!  So the idea is that we leave the
748 OccName alone unless it accidentally clashes with one that is already
749 in scope; if so, we tack on '1' at the end and try again, then '2', and
750 so on till we find a unique one.
751
752 There's a wrinkle for operators.  Consider '>>='.  We can't use '>>=1' 
753 because that isn't a single lexeme.  So we encode it to 'lle' and *then*
754 tack on the '1', if necessary.
755
756 Note [TidyOccEnv]
757 ~~~~~~~~~~~~~~~~~
758 type TidyOccEnv = UniqFM Int
759
760 * Domain = The OccName's FastString. These FastStrings are "taken";
761            make sure that we don't re-use
762
763 * Int, n = A plausible starting point for new guesses
764            There is no guarantee that "FSn" is available; 
765            you must look that up in the TidyOccEnv.  But
766            it's a good place to start looking.
767
768 * When looking for a renaming for "foo2" we strip off the "2" and start
769   with "foo".  Otherwise if we tidy twice we get silly names like foo23.
770
771 \begin{code}
772 type TidyOccEnv = UniqFM Int    -- The in-scope OccNames
773   -- See Note [TidyOccEnv]
774
775 emptyTidyOccEnv :: TidyOccEnv
776 emptyTidyOccEnv = emptyUFM
777
778 initTidyOccEnv :: [OccName] -> TidyOccEnv       -- Initialise with names to avoid!
779 initTidyOccEnv = foldl add emptyUFM
780   where
781     add env (OccName _ fs) = addToUFM env fs 1
782
783 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
784 tidyOccName env occ@(OccName occ_sp fs)
785   = case lookupUFM env fs of
786         Just n  -> find n
787         Nothing -> (addToUFM env fs 1, occ)
788   where
789     base :: String  -- Drop trailing digits (see Note [TidyOccEnv])
790     base = reverse (dropWhile isDigit (reverse (unpackFS fs)))
791  
792     find n 
793       = case lookupUFM env new_fs of
794           Just n' -> find (n1 `max` n')
795                      -- The max ensures that n increases, avoiding loops
796           Nothing -> (addToUFM (addToUFM env fs n1) new_fs n1,
797                       OccName occ_sp new_fs)
798                      -- We update only the beginning and end of the
799                      -- chain that find explores; it's a little harder to
800                      -- update the middle and there's no real need.
801        where
802          n1 = n+1
803          new_fs = mkFastString (base ++ show n)
804 \end{code}
805
806 %************************************************************************
807 %*                                                                      *
808                 Stuff for dealing with tuples
809 %*                                                                      *
810 %************************************************************************
811
812 \begin{code}
813 mkTupleOcc :: NameSpace -> TupleSort -> Arity -> OccName
814 mkTupleOcc ns sort ar = OccName ns (mkFastString str)
815   where
816         -- no need to cache these, the caching is done in the caller
817         -- (TysWiredIn.mk_tuple)
818     str = case sort of
819                 UnboxedTuple    -> '(' : '#' : commas ++ "#)"
820                 BoxedTuple      -> '(' : commas ++ ")"
821                 ConstraintTuple -> '(' : commas ++ ")"
822                   -- Cute hack: reuse the standard tuple OccNames (and hence code)
823                   -- for fact tuples, but give them different Uniques so they are not equal.
824                   --
825                   -- You might think that this will go wrong because isTupleOcc_maybe won't
826                   -- be able to tell the difference between boxed tuples and fact tuples. BUT:
827                   --  1. Fact tuples never occur directly in user code, so it doesn't matter
828                   --     that we can't detect them in Orig OccNames originating from the user
829                   --     programs (or those built by setRdrNameSpace used on an Exact tuple Name)
830                   --  2. Interface files have a special representation for tuple *occurrences*
831                   --     in IfaceTyCons, their workers (in IfaceSyn) and their DataCons (in case
832                   --     alternatives). Thus we don't rely on the OccName to figure out what kind
833                   --     of tuple an occurrence was trying to use in these situations.
834                   --  3. We *don't* represent tuple data type declarations specially, so those
835                   --     are still turned into wired-in names via isTupleOcc_maybe. But that's OK
836                   --     because we don't actually need to declare fact tuples thanks to this hack.
837                   --
838                   -- So basically any OccName like (,,) flowing to isTupleOcc_maybe will always
839                   -- refer to the standard boxed tuple. Cool :-)
840
841     commas = take (ar-1) (repeat ',')
842
843 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, TupleSort, Arity)
844 -- Tuples are special, because there are so many of them!
845 isTupleOcc_maybe (OccName ns fs)
846   = case unpackFS fs of
847         '(':'#':',':rest     -> Just (ns, UnboxedTuple, 2 + count_commas rest)
848         '(':',':rest         -> Just (ns, BoxedTuple,   2 + count_commas rest)
849         _other               -> Nothing
850   where
851     count_commas (',':rest) = 1 + count_commas rest
852     count_commas _          = 0
853 \end{code}
854
855 %************************************************************************
856 %*                                                                      *
857 \subsection{Lexical categories}
858 %*                                                                      *
859 %************************************************************************
860
861 These functions test strings to see if they fit the lexical categories
862 defined in the Haskell report.
863
864 \begin{code}
865 isLexCon,   isLexVar,    isLexId,    isLexSym    :: FastString -> Bool
866 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
867
868 isLexCon cs = isLexConId  cs || isLexConSym cs
869 isLexVar cs = isLexVarId  cs || isLexVarSym cs
870
871 isLexId  cs = isLexConId  cs || isLexVarId  cs
872 isLexSym cs = isLexConSym cs || isLexVarSym cs
873
874 -------------
875
876 isLexConId cs                           -- Prefix type or data constructors
877   | nullFS cs          = False          --      e.g. "Foo", "[]", "(,)" 
878   | cs == (fsLit "[]") = True
879   | otherwise          = startsConId (headFS cs)
880
881 isLexVarId cs                           -- Ordinary prefix identifiers
882   | nullFS cs         = False           --      e.g. "x", "_x"
883   | otherwise         = startsVarId (headFS cs)
884
885 isLexConSym cs                          -- Infix type or data constructors
886   | nullFS cs          = False          --      e.g. ":-:", ":", "->"
887   | cs == (fsLit "->") = True
888   | otherwise          = startsConSym (headFS cs)
889
890 isLexVarSym cs                          -- Infix identifiers
891   | nullFS cs         = False           --      e.g. "+"
892   | otherwise         = startsVarSym (headFS cs)
893
894 -------------
895 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
896 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
897 startsConSym c = c == ':'                               -- Infix data constructors
898 startsVarId c  = isLower c || c == '_'  -- Ordinary Ids
899 startsConId c  = isUpper c || c == '('  -- Ordinary type constructors and data constructors
900
901 isSymbolASCII :: Char -> Bool
902 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
903 \end{code}
904
905 %************************************************************************
906 %*                                                                      *
907                 Binary instance
908     Here rather than BinIface because OccName is abstract
909 %*                                                                      *
910 %************************************************************************
911
912 \begin{code}
913 instance Binary NameSpace where
914     put_ bh VarName = do
915             putByte bh 0
916     put_ bh DataName = do
917             putByte bh 1
918     put_ bh TvName = do
919             putByte bh 2
920     put_ bh TcClsName = do
921             putByte bh 3
922     get bh = do
923             h <- getByte bh
924             case h of
925               0 -> do return VarName
926               1 -> do return DataName
927               2 -> do return TvName
928               _ -> do return TcClsName
929
930 instance Binary OccName where
931     put_ bh (OccName aa ab) = do
932             put_ bh aa
933             put_ bh ab
934     get bh = do
935           aa <- get bh
936           ab <- get bh
937           return (OccName aa ab)
938 \end{code}