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