2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
9 -- GHC uses several kinds of name internally:
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
15 -- * 'RdrName.RdrName': see "RdrName#name_types"
17 -- * 'Name.Name': see "Name#name_types"
19 -- * 'Id.Id': see "Id#name_types"
21 -- * 'Var.Var': see "Var#name_types"
23 -- * The 'NameSpace' type
24 NameSpace, -- Abstract
27 -- $real_vs_source_data_constructors
28 tcName, clsName, tcClsName, dataName, varName,
32 pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
34 -- * The 'OccName' type
35 OccName, -- Abstract, instance of Outputable
39 mkOccName, mkOccNameFS,
41 mkDataOcc, mkDataOccFS,
42 mkTyVarOcc, mkTyVarOccFS,
49 -- ** Derived 'OccName's
51 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc,
52 mkDerivedTyConOcc, mkNewTyCoOcc, mkClassOpAuxOcc,
53 mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
54 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
55 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
56 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc,
57 mkSuperDictSelOcc, mkLocalOcc, mkMethodOcc, mkInstTyTcOcc,
58 mkInstTyCoOcc, mkEqPredCoOcc,
59 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
60 mkPDataTyConOcc, mkPDataDataConOcc,
65 occNameFS, occNameString, occNameSpace,
67 isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
68 parenSymOcc, startsWithUnderscore,
70 isTcClsNameSpace, isTvNameSpace, isDataConNameSpace, isVarNameSpace, isValNameSpace,
74 -- * The 'OccEnv' type
75 OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
76 lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
77 occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
78 extendOccEnv_Acc, filterOccEnv, delListFromOccEnv, delFromOccEnv,
80 -- * The 'OccSet' type
81 OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet,
83 unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts,
84 foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
87 TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
89 -- * Lexical characteristics of Haskell names
90 isLexCon, isLexVar, isLexId, isLexSym,
91 isLexConId, isLexConSym, isLexVarId, isLexVarSym,
92 startsVarSym, startsVarId, startsConSym, startsConId
103 import StaticFlags( opt_SuppressUniques )
108 -- Unicode TODO: put isSymbol in libcompat
109 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
111 isSymbol :: a -> Bool
112 isSymbol = const False
117 %************************************************************************
119 \subsection{Name space}
121 %************************************************************************
124 data NameSpace = VarName -- Variables, including "real" data constructors
125 | DataName -- "Source" data constructors
126 | TvName -- Type variables
127 | TcClsName -- Type constructors and classes; Haskell has them
128 -- in the same name space for now.
130 {-! derive: Binary !-}
132 -- Note [Data Constructors]
133 -- see also: Note [Data Constructor Naming] in DataCon.lhs
135 -- $real_vs_source_data_constructors
136 -- There are two forms of data constructor:
138 -- [Source data constructors] The data constructors mentioned in Haskell source code
140 -- [Real data constructors] The data constructors of the representation type, which may not be the same as the source type
144 -- > data T = T !(Int, Int)
146 -- The source datacon has type @(Int, Int) -> T@
147 -- The real datacon has type @Int -> Int -> T@
149 -- GHC chooses a representation based on the strictness etc.
151 tcName, clsName, tcClsName :: NameSpace
152 dataName, srcDataName :: NameSpace
153 tvName, varName :: NameSpace
155 -- Though type constructors and classes are in the same name space now,
156 -- the NameSpace type is abstract, so we can easily separate them later
157 tcName = TcClsName -- Type constructors
158 clsName = TcClsName -- Classes
159 tcClsName = TcClsName -- Not sure which!
162 srcDataName = DataName -- Haskell-source data constructors should be
163 -- in the Data name space
168 isDataConNameSpace :: NameSpace -> Bool
169 isDataConNameSpace DataName = True
170 isDataConNameSpace _ = False
172 isTcClsNameSpace :: NameSpace -> Bool
173 isTcClsNameSpace TcClsName = True
174 isTcClsNameSpace _ = False
176 isTvNameSpace :: NameSpace -> Bool
177 isTvNameSpace TvName = True
178 isTvNameSpace _ = False
180 isVarNameSpace :: NameSpace -> Bool -- Variables or type variables, but not constructors
181 isVarNameSpace TvName = True
182 isVarNameSpace VarName = True
183 isVarNameSpace _ = False
185 isValNameSpace :: NameSpace -> Bool
186 isValNameSpace DataName = True
187 isValNameSpace VarName = True
188 isValNameSpace _ = False
190 pprNameSpace :: NameSpace -> SDoc
191 pprNameSpace DataName = ptext (sLit "data constructor")
192 pprNameSpace VarName = ptext (sLit "variable")
193 pprNameSpace TvName = ptext (sLit "type variable")
194 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
196 pprNonVarNameSpace :: NameSpace -> SDoc
197 pprNonVarNameSpace VarName = empty
198 pprNonVarNameSpace ns = pprNameSpace ns
200 pprNameSpaceBrief :: NameSpace -> SDoc
201 pprNameSpaceBrief DataName = char 'd'
202 pprNameSpaceBrief VarName = char 'v'
203 pprNameSpaceBrief TvName = ptext (sLit "tv")
204 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
208 %************************************************************************
210 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
212 %************************************************************************
215 data OccName = OccName
216 { occNameSpace :: !NameSpace
217 , occNameFS :: !FastString
223 instance Eq OccName where
224 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
226 instance Ord OccName where
227 -- Compares lexicographically, *not* by Unique of the string
228 compare (OccName sp1 s1) (OccName sp2 s2)
229 = (s1 `compare` s2) `thenCmp` (sp1 `compare` sp2)
233 %************************************************************************
235 \subsection{Printing}
237 %************************************************************************
240 instance Outputable OccName where
243 pprOccName :: OccName -> SDoc
244 pprOccName (OccName sp occ)
245 = getPprStyle $ \ sty ->
247 then ftext (zEncodeFS occ)
248 else pp_occ <> pp_debug sty
250 pp_debug sty | debugStyle sty = braces (pprNameSpaceBrief sp)
253 pp_occ | opt_SuppressUniques = text (strip_th_unique (unpackFS occ))
254 | otherwise = ftext occ
256 -- See Note [Suppressing uniques in OccNames]
257 strip_th_unique ('[' : c : _) | isAlphaNum c = []
258 strip_th_unique (c : cs) = c : strip_th_unique cs
259 strip_th_unique [] = []
262 Note [Suppressing uniques in OccNames]
263 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
264 This is a hack to de-wobblify the OccNames that contain uniques from
265 Template Haskell that have been turned into a string in the OccName.
266 See Note [Unique OccNames from Template Haskell] in Convert.hs
268 %************************************************************************
270 \subsection{Construction}
272 %************************************************************************
275 mkOccName :: NameSpace -> String -> OccName
276 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
278 mkOccNameFS :: NameSpace -> FastString -> OccName
279 mkOccNameFS occ_sp fs = OccName occ_sp fs
281 mkVarOcc :: String -> OccName
282 mkVarOcc s = mkOccName varName s
284 mkVarOccFS :: FastString -> OccName
285 mkVarOccFS fs = mkOccNameFS varName fs
287 mkDataOcc :: String -> OccName
288 mkDataOcc = mkOccName dataName
290 mkDataOccFS :: FastString -> OccName
291 mkDataOccFS = mkOccNameFS dataName
293 mkTyVarOcc :: String -> OccName
294 mkTyVarOcc = mkOccName tvName
296 mkTyVarOccFS :: FastString -> OccName
297 mkTyVarOccFS fs = mkOccNameFS tvName fs
299 mkTcOcc :: String -> OccName
300 mkTcOcc = mkOccName tcName
302 mkTcOccFS :: FastString -> OccName
303 mkTcOccFS = mkOccNameFS tcName
305 mkClsOcc :: String -> OccName
306 mkClsOcc = mkOccName clsName
308 mkClsOccFS :: FastString -> OccName
309 mkClsOccFS = mkOccNameFS clsName
313 %************************************************************************
317 %************************************************************************
319 OccEnvs are used mainly for the envts in ModIfaces.
321 Note [The Unique of an OccName]
322 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
323 They are efficient, because FastStrings have unique Int# keys. We assume
324 this key is less than 2^24, and indeed FastStrings are allocated keys
325 sequentially starting at 0.
327 So we can make a Unique using
328 mkUnique ns key :: Unique
329 where 'ns' is a Char reprsenting the name space. This in turn makes it
330 easy to build an OccEnv.
333 instance Uniquable OccName where
334 -- See Note [The Unique of an OccName]
335 getUnique (OccName VarName fs) = mkVarOccUnique fs
336 getUnique (OccName DataName fs) = mkDataOccUnique fs
337 getUnique (OccName TvName fs) = mkTvOccUnique fs
338 getUnique (OccName TcClsName fs) = mkTcOccUnique fs
340 newtype OccEnv a = A (UniqFM a)
342 emptyOccEnv :: OccEnv a
343 unitOccEnv :: OccName -> a -> OccEnv a
344 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
345 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
346 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
347 mkOccEnv :: [(OccName,a)] -> OccEnv a
348 mkOccEnv_C :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
349 elemOccEnv :: OccName -> OccEnv a -> Bool
350 foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
351 occEnvElts :: OccEnv a -> [a]
352 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
353 extendOccEnv_Acc :: (a->b->b) -> (a->b) -> OccEnv b -> OccName -> a -> OccEnv b
354 plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
355 plusOccEnv_C :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
356 mapOccEnv :: (a->b) -> OccEnv a -> OccEnv b
357 delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
358 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
359 filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
361 emptyOccEnv = A emptyUFM
362 unitOccEnv x y = A $ unitUFM x y
363 extendOccEnv (A x) y z = A $ addToUFM x y z
364 extendOccEnvList (A x) l = A $ addListToUFM x l
365 lookupOccEnv (A x) y = lookupUFM x y
366 mkOccEnv l = A $ listToUFM l
367 elemOccEnv x (A y) = elemUFM x y
368 foldOccEnv a b (A c) = foldUFM a b c
369 occEnvElts (A x) = eltsUFM x
370 plusOccEnv (A x) (A y) = A $ plusUFM x y
371 plusOccEnv_C f (A x) (A y) = A $ plusUFM_C f x y
372 extendOccEnv_C f (A x) y z = A $ addToUFM_C f x y z
373 extendOccEnv_Acc f g (A x) y z = A $ addToUFM_Acc f g x y z
374 mapOccEnv f (A x) = A $ mapUFM f x
375 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
376 delFromOccEnv (A x) y = A $ delFromUFM x y
377 delListFromOccEnv (A x) y = A $ delListFromUFM x y
378 filterOccEnv x (A y) = A $ filterUFM x y
380 instance Outputable a => Outputable (OccEnv a) where
383 type OccSet = UniqSet OccName
385 emptyOccSet :: OccSet
386 unitOccSet :: OccName -> OccSet
387 mkOccSet :: [OccName] -> OccSet
388 extendOccSet :: OccSet -> OccName -> OccSet
389 extendOccSetList :: OccSet -> [OccName] -> OccSet
390 unionOccSets :: OccSet -> OccSet -> OccSet
391 unionManyOccSets :: [OccSet] -> OccSet
392 minusOccSet :: OccSet -> OccSet -> OccSet
393 elemOccSet :: OccName -> OccSet -> Bool
394 occSetElts :: OccSet -> [OccName]
395 foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
396 isEmptyOccSet :: OccSet -> Bool
397 intersectOccSet :: OccSet -> OccSet -> OccSet
398 intersectsOccSet :: OccSet -> OccSet -> Bool
400 emptyOccSet = emptyUniqSet
401 unitOccSet = unitUniqSet
403 extendOccSet = addOneToUniqSet
404 extendOccSetList = addListToUniqSet
405 unionOccSets = unionUniqSets
406 unionManyOccSets = unionManyUniqSets
407 minusOccSet = minusUniqSet
408 elemOccSet = elementOfUniqSet
409 occSetElts = uniqSetToList
410 foldOccSet = foldUniqSet
411 isEmptyOccSet = isEmptyUniqSet
412 intersectOccSet = intersectUniqSets
413 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
417 %************************************************************************
419 \subsection{Predicates and taking them apart}
421 %************************************************************************
424 occNameString :: OccName -> String
425 occNameString (OccName _ s) = unpackFS s
427 setOccNameSpace :: NameSpace -> OccName -> OccName
428 setOccNameSpace sp (OccName _ occ) = OccName sp occ
430 isVarOcc, isTvOcc, isTcOcc, isDataOcc :: OccName -> Bool
432 isVarOcc (OccName VarName _) = True
435 isTvOcc (OccName TvName _) = True
438 isTcOcc (OccName TcClsName _) = True
441 -- | /Value/ 'OccNames's are those that are either in
442 -- the variable or data constructor namespaces
443 isValOcc :: OccName -> Bool
444 isValOcc (OccName VarName _) = True
445 isValOcc (OccName DataName _) = True
448 isDataOcc (OccName DataName _) = True
449 isDataOcc (OccName VarName s)
450 | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
451 -- Jan06: I don't think this should happen
454 -- | Test if the 'OccName' is a data constructor that starts with
455 -- a symbol (e.g. @:@, or @[]@)
456 isDataSymOcc :: OccName -> Bool
457 isDataSymOcc (OccName DataName s) = isLexConSym s
458 isDataSymOcc (OccName VarName s)
459 | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
460 -- Jan06: I don't think this should happen
461 isDataSymOcc _ = False
462 -- Pretty inefficient!
464 -- | Test if the 'OccName' is that for any operator (whether
465 -- it is a data constructor or variable or whatever)
466 isSymOcc :: OccName -> Bool
467 isSymOcc (OccName DataName s) = isLexConSym s
468 isSymOcc (OccName TcClsName s) = isLexConSym s
469 isSymOcc (OccName VarName s) = isLexSym s
470 isSymOcc (OccName TvName s) = isLexSym s
471 -- Pretty inefficient!
473 parenSymOcc :: OccName -> SDoc -> SDoc
474 -- ^ Wrap parens around an operator
475 parenSymOcc occ doc | isSymOcc occ = parens doc
481 startsWithUnderscore :: OccName -> Bool
482 -- ^ Haskell 98 encourages compilers to suppress warnings about unsed
483 -- names in a pattern if they start with @_@: this implements that test
484 startsWithUnderscore occ = case occNameString occ of
490 %************************************************************************
492 \subsection{Making system names}
494 %************************************************************************
496 Here's our convention for splitting up the interface file name space:
498 d... dictionary identifiers
499 (local variables, so no name-clash worries)
501 All of these other OccNames contain a mixture of alphabetic
502 and symbolic characters, and hence cannot possibly clash with
503 a user-written type or function name
505 $f... Dict-fun identifiers (from inst decls)
506 $dmop Default method for 'op'
507 $pnC n'th superclass selector for class C
508 $wf Worker for functtoin 'f'
509 $sf.. Specialised version of f
510 T:C Tycon for dictionary for class C
511 D:C Data constructor for dictionary for class C
512 NTCo:T Coercion connecting newtype T with its representation type
513 TFCo:R Coercion connecting a data family to its respresentation type R
515 In encoded form these appear as Zdfxxx etc
517 :... keywords (export:, letrec: etc.)
518 --- I THINK THIS IS WRONG!
520 This knowledge is encoded in the following functions.
522 @mk_deriv@ generates an @OccName@ from the prefix and a string.
523 NB: The string must already be encoded!
526 mk_deriv :: NameSpace
527 -> String -- Distinguishes one sort of derived name from another
531 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
533 isDerivedOccName :: OccName -> Bool
534 isDerivedOccName occ =
535 case occNameString occ of
536 '$':c:_ | isAlphaNum c -> True
537 ':':c:_ | isAlphaNum c -> True
542 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
543 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
544 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
545 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
546 mkInstTyCoOcc, mkEqPredCoOcc, mkClassOpAuxOcc,
547 mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
548 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
549 mkPDataTyConOcc, mkPDataDataConOcc, mkPReprTyConOcc, mkPADFunOcc
550 :: OccName -> OccName
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 mkClassOpAuxOcc = mk_simple_deriv varName "$c"
557 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
558 mkClassTyConOcc = mk_simple_deriv tcName "T:" -- 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"
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_"
574 -- Generic derivable classes
575 mkGenOcc1 = mk_simple_deriv varName "$gfrom"
576 mkGenOcc2 = mk_simple_deriv varName "$gto"
578 -- data T = MkT ... deriving( Data ) needs defintions for
579 -- $tT :: Data.Generics.Basics.DataType
580 -- $cMkT :: Data.Generics.Basics.Constr
581 mkDataTOcc = mk_simple_deriv varName "$t"
582 mkDataCOcc = mk_simple_deriv varName "$c"
585 mkVectOcc = mk_simple_deriv varName "$v_"
586 mkVectTyConOcc = mk_simple_deriv tcName ":V_"
587 mkVectDataConOcc = mk_simple_deriv dataName ":VD_"
588 mkVectIsoOcc = mk_simple_deriv varName "$VI_"
589 mkPDataTyConOcc = mk_simple_deriv tcName ":VP_"
590 mkPDataDataConOcc = mk_simple_deriv dataName ":VPD_"
591 mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
592 mkPADFunOcc = mk_simple_deriv varName "$PA_"
594 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
595 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
597 -- Data constructor workers are made by setting the name space
598 -- of the data constructor OccName (which should be a DataName)
600 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
604 mkSuperDictSelOcc :: Int -- ^ Index of superclass, e.g. 3
605 -> OccName -- ^ Class, e.g. @Ord@
606 -> OccName -- ^ Derived 'Occname', e.g. @$p3Ord@
607 mkSuperDictSelOcc index cls_occ
608 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
610 mkLocalOcc :: Unique -- ^ Unique to combine with the 'OccName'
611 -> OccName -- ^ Local name, e.g. @sat@
612 -> OccName -- ^ Nice unique version, e.g. @$L23sat@
614 = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
615 -- The Unique might print with characters
616 -- that need encoding (e.g. 'z'!)
620 -- | Derive a name for the representation type constructor of a
621 -- @data@\/@newtype@ instance.
622 mkInstTyTcOcc :: String -- ^ Family name, e.g. @Map@
623 -> OccSet -- ^ avoid these Occs
624 -> OccName -- ^ @R:Map@
625 mkInstTyTcOcc str set =
626 chooseUniqueOcc tcName ('R' : ':' : str) set
630 mkDFunOcc :: String -- ^ Typically the class and type glommed together e.g. @OrdMaybe@.
631 -- Only used in debug mode, for extra clarity
632 -> Bool -- ^ Is this a hs-boot instance DFun?
633 -> OccSet -- ^ avoid these Occs
634 -> OccName -- ^ E.g. @$f3OrdMaybe@
636 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
637 -- thing when we compile the mother module. Reason: we don't know exactly
638 -- what the mother module will call it.
640 mkDFunOcc info_str is_boot set
641 = chooseUniqueOcc VarName (prefix ++ info_str) set
643 prefix | is_boot = "$fx"
647 Sometimes we need to pick an OccName that has not already been used,
648 given a set of in-use OccNames.
651 chooseUniqueOcc :: NameSpace -> String -> OccSet -> OccName
652 chooseUniqueOcc ns str set = loop (mkOccName ns str) (0::Int)
655 | occ `elemOccSet` set = loop (mkOccName ns (str ++ show n)) (n+1)
659 We used to add a '$m' to indicate a method, but that gives rise to bad
660 error messages from the type checker when we print the function name or pattern
661 of an instance-decl binding. Why? Because the binding is zapped
662 to use the method name in place of the selector name.
663 (See TcClassDcl.tcMethodBind)
665 The way it is now, -ddump-xx output may look confusing, but
666 you can always say -dppr-debug to get the uniques.
668 However, we *do* have to zap the first character to be lower case,
669 because overloaded constructors (blarg) generate methods too.
670 And convert to VarName space
672 e.g. a call to constructor MkFoo where
673 data (Ord a) => Foo a = MkFoo a
675 If this is necessary, we do it by prefixing '$m'. These
676 guys never show up in error messages. What a hack.
679 mkMethodOcc :: OccName -> OccName
680 mkMethodOcc occ@(OccName VarName _) = occ
681 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
685 %************************************************************************
687 \subsection{Tidying them up}
689 %************************************************************************
691 Before we print chunks of code we like to rename it so that
692 we don't have to print lots of silly uniques in it. But we mustn't
693 accidentally introduce name clashes! So the idea is that we leave the
694 OccName alone unless it accidentally clashes with one that is already
695 in scope; if so, we tack on '1' at the end and try again, then '2', and
696 so on till we find a unique one.
698 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
699 because that isn't a single lexeme. So we encode it to 'lle' and *then*
700 tack on the '1', if necessary.
703 type TidyOccEnv = OccEnv Int -- The in-scope OccNames
704 -- Range gives a plausible starting point for new guesses
706 emptyTidyOccEnv :: TidyOccEnv
707 emptyTidyOccEnv = emptyOccEnv
709 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
710 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
712 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
714 tidyOccName in_scope occ@(OccName occ_sp fs)
715 = case lookupOccEnv in_scope occ of
716 Nothing -> -- Not already used: make it used
717 (extendOccEnv in_scope occ 1, occ)
719 Just n -> -- Already used: make a new guess,
720 -- change the guess base, and try again
721 tidyOccName (extendOccEnv in_scope occ (n+1))
722 (mkOccName occ_sp (unpackFS fs ++ show n))
725 %************************************************************************
727 Stuff for dealing with tuples
729 %************************************************************************
732 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
733 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
735 -- no need to cache these, the caching is done in the caller
736 -- (TysWiredIn.mk_tuple)
738 Boxed -> '(' : commas ++ ")"
739 Unboxed -> '(' : '#' : commas ++ "#)"
741 commas = take (ar-1) (repeat ',')
743 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
744 -- Tuples are special, because there are so many of them!
745 isTupleOcc_maybe (OccName ns fs)
746 = case unpackFS fs of
747 '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
748 '(':',':rest -> Just (ns, Boxed, 2 + count_commas rest)
751 count_commas (',':rest) = 1 + count_commas rest
755 %************************************************************************
757 \subsection{Lexical categories}
759 %************************************************************************
761 These functions test strings to see if they fit the lexical categories
762 defined in the Haskell report.
765 isLexCon, isLexVar, isLexId, isLexSym :: FastString -> Bool
766 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
768 isLexCon cs = isLexConId cs || isLexConSym cs
769 isLexVar cs = isLexVarId cs || isLexVarSym cs
771 isLexId cs = isLexConId cs || isLexVarId cs
772 isLexSym cs = isLexConSym cs || isLexVarSym cs
776 isLexConId cs -- Prefix type or data constructors
777 | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
778 | cs == (fsLit "[]") = True
779 | otherwise = startsConId (headFS cs)
781 isLexVarId cs -- Ordinary prefix identifiers
782 | nullFS cs = False -- e.g. "x", "_x"
783 | otherwise = startsVarId (headFS cs)
785 isLexConSym cs -- Infix type or data constructors
786 | nullFS cs = False -- e.g. ":-:", ":", "->"
787 | cs == (fsLit "->") = True
788 | otherwise = startsConSym (headFS cs)
790 isLexVarSym cs -- Infix identifiers
791 | nullFS cs = False -- e.g. "+"
792 | otherwise = startsVarSym (headFS cs)
795 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
796 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
797 startsConSym c = c == ':' -- Infix data constructors
798 startsVarId c = isLower c || c == '_' -- Ordinary Ids
799 startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
801 isSymbolASCII :: Char -> Bool
802 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
805 %************************************************************************
808 Here rather than BinIface because OccName is abstract
810 %************************************************************************
813 instance Binary NameSpace where
816 put_ bh DataName = do
820 put_ bh TcClsName = do
825 0 -> do return VarName
826 1 -> do return DataName
827 2 -> do return TvName
828 _ -> do return TcClsName
830 instance Binary OccName where
831 put_ bh (OccName aa ab) = do
837 return (OccName aa ab)