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