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
105 import StaticFlags( opt_SuppressUniques )
111 -- Unicode TODO: put isSymbol in libcompat
112 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
114 isSymbol :: a -> Bool
115 isSymbol = const False
120 %************************************************************************
122 \subsection{Name space}
124 %************************************************************************
127 data NameSpace = VarName -- Variables, including "real" data constructors
128 | DataName -- "Source" data constructors
129 | TvName -- Type variables
130 | TcClsName -- Type constructors and classes; Haskell has them
131 -- in the same name space for now.
133 {-! derive: Binary !-}
135 -- Note [Data Constructors]
136 -- see also: Note [Data Constructor Naming] in DataCon.lhs
138 -- $real_vs_source_data_constructors
139 -- There are two forms of data constructor:
141 -- [Source data constructors] The data constructors mentioned in Haskell source code
143 -- [Real data constructors] The data constructors of the representation type, which may not be the same as the source type
147 -- > data T = T !(Int, Int)
149 -- The source datacon has type @(Int, Int) -> T@
150 -- The real datacon has type @Int -> Int -> T@
152 -- GHC chooses a representation based on the strictness etc.
154 tcName, clsName, tcClsName :: NameSpace
155 dataName, srcDataName :: NameSpace
156 tvName, varName :: NameSpace
158 -- Though type constructors and classes are in the same name space now,
159 -- the NameSpace type is abstract, so we can easily separate them later
160 tcName = TcClsName -- Type constructors
161 clsName = TcClsName -- Classes
162 tcClsName = TcClsName -- Not sure which!
165 srcDataName = DataName -- Haskell-source data constructors should be
166 -- in the Data name space
171 isDataConNameSpace :: NameSpace -> Bool
172 isDataConNameSpace DataName = True
173 isDataConNameSpace _ = False
175 isTcClsNameSpace :: NameSpace -> Bool
176 isTcClsNameSpace TcClsName = True
177 isTcClsNameSpace _ = False
179 isTvNameSpace :: NameSpace -> Bool
180 isTvNameSpace TvName = True
181 isTvNameSpace _ = False
183 isVarNameSpace :: NameSpace -> Bool -- Variables or type variables, but not constructors
184 isVarNameSpace TvName = True
185 isVarNameSpace VarName = True
186 isVarNameSpace _ = False
188 isValNameSpace :: NameSpace -> Bool
189 isValNameSpace DataName = True
190 isValNameSpace VarName = True
191 isValNameSpace _ = False
193 pprNameSpace :: NameSpace -> SDoc
194 pprNameSpace DataName = ptext (sLit "data constructor")
195 pprNameSpace VarName = ptext (sLit "variable")
196 pprNameSpace TvName = ptext (sLit "type variable")
197 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
199 pprNonVarNameSpace :: NameSpace -> SDoc
200 pprNonVarNameSpace VarName = empty
201 pprNonVarNameSpace ns = pprNameSpace ns
203 pprNameSpaceBrief :: NameSpace -> SDoc
204 pprNameSpaceBrief DataName = char 'd'
205 pprNameSpaceBrief VarName = char 'v'
206 pprNameSpaceBrief TvName = ptext (sLit "tv")
207 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
211 %************************************************************************
213 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
215 %************************************************************************
218 data OccName = OccName
219 { occNameSpace :: !NameSpace
220 , occNameFS :: !FastString
226 instance Eq OccName where
227 (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
229 instance Ord OccName where
230 -- Compares lexicographically, *not* by Unique of the string
231 compare (OccName sp1 s1) (OccName sp2 s2)
232 = (s1 `compare` s2) `thenCmp` (sp1 `compare` sp2)
234 INSTANCE_TYPEABLE0(OccName,occNameTc,"OccName")
236 instance Data OccName where
238 toConstr _ = abstractConstr "OccName"
239 gunfold _ _ = error "gunfold"
240 dataTypeOf _ = mkNoRepType "OccName"
244 %************************************************************************
246 \subsection{Printing}
248 %************************************************************************
251 instance Outputable OccName where
254 pprOccName :: OccName -> SDoc
255 pprOccName (OccName sp occ)
256 = getPprStyle $ \ sty ->
258 then ftext (zEncodeFS occ)
259 else pp_occ <> pp_debug sty
261 pp_debug sty | debugStyle sty = braces (pprNameSpaceBrief sp)
264 pp_occ | opt_SuppressUniques = text (strip_th_unique (unpackFS occ))
265 | otherwise = ftext occ
267 -- See Note [Suppressing uniques in OccNames]
268 strip_th_unique ('[' : c : _) | isAlphaNum c = []
269 strip_th_unique (c : cs) = c : strip_th_unique cs
270 strip_th_unique [] = []
273 Note [Suppressing uniques in OccNames]
274 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
275 This is a hack to de-wobblify the OccNames that contain uniques from
276 Template Haskell that have been turned into a string in the OccName.
277 See Note [Unique OccNames from Template Haskell] in Convert.hs
279 %************************************************************************
281 \subsection{Construction}
283 %************************************************************************
286 mkOccName :: NameSpace -> String -> OccName
287 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
289 mkOccNameFS :: NameSpace -> FastString -> OccName
290 mkOccNameFS occ_sp fs = OccName occ_sp fs
292 mkVarOcc :: String -> OccName
293 mkVarOcc s = mkOccName varName s
295 mkVarOccFS :: FastString -> OccName
296 mkVarOccFS fs = mkOccNameFS varName fs
298 mkDataOcc :: String -> OccName
299 mkDataOcc = mkOccName dataName
301 mkDataOccFS :: FastString -> OccName
302 mkDataOccFS = mkOccNameFS dataName
304 mkTyVarOcc :: String -> OccName
305 mkTyVarOcc = mkOccName tvName
307 mkTyVarOccFS :: FastString -> OccName
308 mkTyVarOccFS fs = mkOccNameFS tvName fs
310 mkTcOcc :: String -> OccName
311 mkTcOcc = mkOccName tcName
313 mkTcOccFS :: FastString -> OccName
314 mkTcOccFS = mkOccNameFS tcName
316 mkClsOcc :: String -> OccName
317 mkClsOcc = mkOccName clsName
319 mkClsOccFS :: FastString -> OccName
320 mkClsOccFS = mkOccNameFS clsName
324 %************************************************************************
328 %************************************************************************
330 OccEnvs are used mainly for the envts in ModIfaces.
332 Note [The Unique of an OccName]
333 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
334 They are efficient, because FastStrings have unique Int# keys. We assume
335 this key is less than 2^24, and indeed FastStrings are allocated keys
336 sequentially starting at 0.
338 So we can make a Unique using
339 mkUnique ns key :: Unique
340 where 'ns' is a Char reprsenting the name space. This in turn makes it
341 easy to build an OccEnv.
344 instance Uniquable OccName where
345 -- See Note [The Unique of an OccName]
346 getUnique (OccName VarName fs) = mkVarOccUnique fs
347 getUnique (OccName DataName fs) = mkDataOccUnique fs
348 getUnique (OccName TvName fs) = mkTvOccUnique fs
349 getUnique (OccName TcClsName fs) = mkTcOccUnique fs
351 newtype OccEnv a = A (UniqFM a)
353 emptyOccEnv :: OccEnv a
354 unitOccEnv :: OccName -> a -> OccEnv a
355 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
356 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
357 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
358 mkOccEnv :: [(OccName,a)] -> OccEnv a
359 mkOccEnv_C :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
360 elemOccEnv :: OccName -> OccEnv a -> Bool
361 foldOccEnv :: (a -> b -> b) -> b -> OccEnv a -> b
362 occEnvElts :: OccEnv a -> [a]
363 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
364 extendOccEnv_Acc :: (a->b->b) -> (a->b) -> OccEnv b -> OccName -> a -> OccEnv b
365 plusOccEnv :: OccEnv a -> OccEnv a -> OccEnv a
366 plusOccEnv_C :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
367 mapOccEnv :: (a->b) -> OccEnv a -> OccEnv b
368 delFromOccEnv :: OccEnv a -> OccName -> OccEnv a
369 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
370 filterOccEnv :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
372 emptyOccEnv = A emptyUFM
373 unitOccEnv x y = A $ unitUFM x y
374 extendOccEnv (A x) y z = A $ addToUFM x y z
375 extendOccEnvList (A x) l = A $ addListToUFM x l
376 lookupOccEnv (A x) y = lookupUFM x y
377 mkOccEnv l = A $ listToUFM l
378 elemOccEnv x (A y) = elemUFM x y
379 foldOccEnv a b (A c) = foldUFM a b c
380 occEnvElts (A x) = eltsUFM x
381 plusOccEnv (A x) (A y) = A $ plusUFM x y
382 plusOccEnv_C f (A x) (A y) = A $ plusUFM_C f x y
383 extendOccEnv_C f (A x) y z = A $ addToUFM_C f x y z
384 extendOccEnv_Acc f g (A x) y z = A $ addToUFM_Acc f g x y z
385 mapOccEnv f (A x) = A $ mapUFM f x
386 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
387 delFromOccEnv (A x) y = A $ delFromUFM x y
388 delListFromOccEnv (A x) y = A $ delListFromUFM x y
389 filterOccEnv x (A y) = A $ filterUFM x y
391 instance Outputable a => Outputable (OccEnv a) where
394 type OccSet = UniqSet OccName
396 emptyOccSet :: OccSet
397 unitOccSet :: OccName -> OccSet
398 mkOccSet :: [OccName] -> OccSet
399 extendOccSet :: OccSet -> OccName -> OccSet
400 extendOccSetList :: OccSet -> [OccName] -> OccSet
401 unionOccSets :: OccSet -> OccSet -> OccSet
402 unionManyOccSets :: [OccSet] -> OccSet
403 minusOccSet :: OccSet -> OccSet -> OccSet
404 elemOccSet :: OccName -> OccSet -> Bool
405 occSetElts :: OccSet -> [OccName]
406 foldOccSet :: (OccName -> b -> b) -> b -> OccSet -> b
407 isEmptyOccSet :: OccSet -> Bool
408 intersectOccSet :: OccSet -> OccSet -> OccSet
409 intersectsOccSet :: OccSet -> OccSet -> Bool
411 emptyOccSet = emptyUniqSet
412 unitOccSet = unitUniqSet
414 extendOccSet = addOneToUniqSet
415 extendOccSetList = addListToUniqSet
416 unionOccSets = unionUniqSets
417 unionManyOccSets = unionManyUniqSets
418 minusOccSet = minusUniqSet
419 elemOccSet = elementOfUniqSet
420 occSetElts = uniqSetToList
421 foldOccSet = foldUniqSet
422 isEmptyOccSet = isEmptyUniqSet
423 intersectOccSet = intersectUniqSets
424 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
428 %************************************************************************
430 \subsection{Predicates and taking them apart}
432 %************************************************************************
435 occNameString :: OccName -> String
436 occNameString (OccName _ s) = unpackFS s
438 setOccNameSpace :: NameSpace -> OccName -> OccName
439 setOccNameSpace sp (OccName _ occ) = OccName sp occ
441 isVarOcc, isTvOcc, isTcOcc, isDataOcc :: OccName -> Bool
443 isVarOcc (OccName VarName _) = True
446 isTvOcc (OccName TvName _) = True
449 isTcOcc (OccName TcClsName _) = True
452 -- | /Value/ 'OccNames's are those that are either in
453 -- the variable or data constructor namespaces
454 isValOcc :: OccName -> Bool
455 isValOcc (OccName VarName _) = True
456 isValOcc (OccName DataName _) = True
459 isDataOcc (OccName DataName _) = True
460 isDataOcc (OccName VarName s)
461 | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
462 -- Jan06: I don't think this should happen
465 -- | Test if the 'OccName' is a data constructor that starts with
466 -- a symbol (e.g. @:@, or @[]@)
467 isDataSymOcc :: OccName -> Bool
468 isDataSymOcc (OccName DataName s) = isLexConSym s
469 isDataSymOcc (OccName VarName s)
470 | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
471 -- Jan06: I don't think this should happen
472 isDataSymOcc _ = False
473 -- Pretty inefficient!
475 -- | Test if the 'OccName' is that for any operator (whether
476 -- it is a data constructor or variable or whatever)
477 isSymOcc :: OccName -> Bool
478 isSymOcc (OccName DataName s) = isLexConSym s
479 isSymOcc (OccName TcClsName s) = isLexConSym s
480 isSymOcc (OccName VarName s) = isLexSym s
481 isSymOcc (OccName TvName s) = isLexSym s
482 -- Pretty inefficient!
484 parenSymOcc :: OccName -> SDoc -> SDoc
485 -- ^ Wrap parens around an operator
486 parenSymOcc occ doc | isSymOcc occ = parens doc
492 startsWithUnderscore :: OccName -> Bool
493 -- ^ Haskell 98 encourages compilers to suppress warnings about unsed
494 -- names in a pattern if they start with @_@: this implements that test
495 startsWithUnderscore occ = case occNameString occ of
501 %************************************************************************
503 \subsection{Making system names}
505 %************************************************************************
507 Here's our convention for splitting up the interface file name space:
509 d... dictionary identifiers
510 (local variables, so no name-clash worries)
512 All of these other OccNames contain a mixture of alphabetic
513 and symbolic characters, and hence cannot possibly clash with
514 a user-written type or function name
516 $f... Dict-fun identifiers (from inst decls)
517 $dmop Default method for 'op'
518 $pnC n'th superclass selector for class C
519 $wf Worker for functtoin 'f'
520 $sf.. Specialised version of f
521 T:C Tycon for dictionary for class C
522 D:C Data constructor for dictionary for class C
523 NTCo:T Coercion connecting newtype T with its representation type
524 TFCo:R Coercion connecting a data family to its respresentation type R
526 In encoded form these appear as Zdfxxx etc
528 :... keywords (export:, letrec: etc.)
529 --- I THINK THIS IS WRONG!
531 This knowledge is encoded in the following functions.
533 @mk_deriv@ generates an @OccName@ from the prefix and a string.
534 NB: The string must already be encoded!
537 mk_deriv :: NameSpace
538 -> String -- Distinguishes one sort of derived name from another
542 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
544 isDerivedOccName :: OccName -> Bool
545 isDerivedOccName occ =
546 case occNameString occ of
547 '$':c:_ | isAlphaNum c -> True
548 ':':c:_ | isAlphaNum c -> True
553 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
554 mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
555 mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
556 mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
557 mkInstTyCoOcc, mkEqPredCoOcc, mkClassOpAuxOcc,
558 mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
559 mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
560 mkPDataTyConOcc, mkPDataDataConOcc, mkPReprTyConOcc, mkPADFunOcc
561 :: OccName -> OccName
563 -- These derived variables have a prefix that no Haskell value could have
564 mkDataConWrapperOcc = mk_simple_deriv varName "$W"
565 mkWorkerOcc = mk_simple_deriv varName "$w"
566 mkDefaultMethodOcc = mk_simple_deriv varName "$dm"
567 mkClassOpAuxOcc = mk_simple_deriv varName "$c"
568 mkDerivedTyConOcc = mk_simple_deriv tcName ":" -- The : prefix makes sure it classifies
569 mkClassTyConOcc = mk_simple_deriv tcName "T:" -- as a tycon/datacon
570 mkClassDataConOcc = mk_simple_deriv dataName "D:" -- We go straight to the "real" data con
571 -- for datacons from classes
572 mkDictOcc = mk_simple_deriv varName "$d"
573 mkIPOcc = mk_simple_deriv varName "$i"
574 mkSpecOcc = mk_simple_deriv varName "$s"
575 mkForeignExportOcc = mk_simple_deriv varName "$f"
576 mkNewTyCoOcc = mk_simple_deriv tcName "NTCo:" -- Coercion for newtypes
577 mkInstTyCoOcc = mk_simple_deriv tcName "TFCo:" -- Coercion for type functions
578 mkEqPredCoOcc = mk_simple_deriv tcName "$co"
580 -- used in derived instances
581 mkCon2TagOcc = mk_simple_deriv varName "$con2tag_"
582 mkTag2ConOcc = mk_simple_deriv varName "$tag2con_"
583 mkMaxTagOcc = mk_simple_deriv varName "$maxtag_"
585 -- Generic derivable classes
586 mkGenOcc1 = mk_simple_deriv varName "$gfrom"
587 mkGenOcc2 = mk_simple_deriv varName "$gto"
589 -- data T = MkT ... deriving( Data ) needs defintions for
590 -- $tT :: Data.Generics.Basics.DataType
591 -- $cMkT :: Data.Generics.Basics.Constr
592 mkDataTOcc = mk_simple_deriv varName "$t"
593 mkDataCOcc = mk_simple_deriv varName "$c"
596 mkVectOcc = mk_simple_deriv varName "$v_"
597 mkVectTyConOcc = mk_simple_deriv tcName ":V_"
598 mkVectDataConOcc = mk_simple_deriv dataName ":VD_"
599 mkVectIsoOcc = mk_simple_deriv varName "$VI_"
600 mkPDataTyConOcc = mk_simple_deriv tcName ":VP_"
601 mkPDataDataConOcc = mk_simple_deriv dataName ":VPD_"
602 mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
603 mkPADFunOcc = mk_simple_deriv varName "$PA_"
605 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
606 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
608 -- Data constructor workers are made by setting the name space
609 -- of the data constructor OccName (which should be a DataName)
611 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
615 mkSuperDictSelOcc :: Int -- ^ Index of superclass, e.g. 3
616 -> OccName -- ^ Class, e.g. @Ord@
617 -> OccName -- ^ Derived 'Occname', e.g. @$p3Ord@
618 mkSuperDictSelOcc index cls_occ
619 = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
621 mkLocalOcc :: Unique -- ^ Unique to combine with the 'OccName'
622 -> OccName -- ^ Local name, e.g. @sat@
623 -> OccName -- ^ Nice unique version, e.g. @$L23sat@
625 = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
626 -- The Unique might print with characters
627 -- that need encoding (e.g. 'z'!)
631 -- | Derive a name for the representation type constructor of a
632 -- @data@\/@newtype@ instance.
633 mkInstTyTcOcc :: String -- ^ Family name, e.g. @Map@
634 -> OccSet -- ^ avoid these Occs
635 -> OccName -- ^ @R:Map@
636 mkInstTyTcOcc str set =
637 chooseUniqueOcc tcName ('R' : ':' : str) set
641 mkDFunOcc :: String -- ^ Typically the class and type glommed together e.g. @OrdMaybe@.
642 -- Only used in debug mode, for extra clarity
643 -> Bool -- ^ Is this a hs-boot instance DFun?
644 -> OccSet -- ^ avoid these Occs
645 -> OccName -- ^ E.g. @$f3OrdMaybe@
647 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
648 -- thing when we compile the mother module. Reason: we don't know exactly
649 -- what the mother module will call it.
651 mkDFunOcc info_str is_boot set
652 = chooseUniqueOcc VarName (prefix ++ info_str) set
654 prefix | is_boot = "$fx"
658 Sometimes we need to pick an OccName that has not already been used,
659 given a set of in-use OccNames.
662 chooseUniqueOcc :: NameSpace -> String -> OccSet -> OccName
663 chooseUniqueOcc ns str set = loop (mkOccName ns str) (0::Int)
666 | occ `elemOccSet` set = loop (mkOccName ns (str ++ show n)) (n+1)
670 We used to add a '$m' to indicate a method, but that gives rise to bad
671 error messages from the type checker when we print the function name or pattern
672 of an instance-decl binding. Why? Because the binding is zapped
673 to use the method name in place of the selector name.
674 (See TcClassDcl.tcMethodBind)
676 The way it is now, -ddump-xx output may look confusing, but
677 you can always say -dppr-debug to get the uniques.
679 However, we *do* have to zap the first character to be lower case,
680 because overloaded constructors (blarg) generate methods too.
681 And convert to VarName space
683 e.g. a call to constructor MkFoo where
684 data (Ord a) => Foo a = MkFoo a
686 If this is necessary, we do it by prefixing '$m'. These
687 guys never show up in error messages. What a hack.
690 mkMethodOcc :: OccName -> OccName
691 mkMethodOcc occ@(OccName VarName _) = occ
692 mkMethodOcc occ = mk_simple_deriv varName "$m" occ
696 %************************************************************************
698 \subsection{Tidying them up}
700 %************************************************************************
702 Before we print chunks of code we like to rename it so that
703 we don't have to print lots of silly uniques in it. But we mustn't
704 accidentally introduce name clashes! So the idea is that we leave the
705 OccName alone unless it accidentally clashes with one that is already
706 in scope; if so, we tack on '1' at the end and try again, then '2', and
707 so on till we find a unique one.
709 There's a wrinkle for operators. Consider '>>='. We can't use '>>=1'
710 because that isn't a single lexeme. So we encode it to 'lle' and *then*
711 tack on the '1', if necessary.
714 type TidyOccEnv = OccEnv Int -- The in-scope OccNames
715 -- Range gives a plausible starting point for new guesses
717 emptyTidyOccEnv :: TidyOccEnv
718 emptyTidyOccEnv = emptyOccEnv
720 initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
721 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
723 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
725 tidyOccName in_scope occ@(OccName occ_sp fs)
726 = case lookupOccEnv in_scope occ of
727 Nothing -> -- Not already used: make it used
728 (extendOccEnv in_scope occ 1, occ)
730 Just n -> -- Already used: make a new guess,
731 -- change the guess base, and try again
732 tidyOccName (extendOccEnv in_scope occ (n+1))
733 (mkOccName occ_sp (unpackFS fs ++ show n))
736 %************************************************************************
738 Stuff for dealing with tuples
740 %************************************************************************
743 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
744 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
746 -- no need to cache these, the caching is done in the caller
747 -- (TysWiredIn.mk_tuple)
749 Boxed -> '(' : commas ++ ")"
750 Unboxed -> '(' : '#' : commas ++ "#)"
752 commas = take (ar-1) (repeat ',')
754 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
755 -- Tuples are special, because there are so many of them!
756 isTupleOcc_maybe (OccName ns fs)
757 = case unpackFS fs of
758 '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
759 '(':',':rest -> Just (ns, Boxed, 2 + count_commas rest)
762 count_commas (',':rest) = 1 + count_commas rest
766 %************************************************************************
768 \subsection{Lexical categories}
770 %************************************************************************
772 These functions test strings to see if they fit the lexical categories
773 defined in the Haskell report.
776 isLexCon, isLexVar, isLexId, isLexSym :: FastString -> Bool
777 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
779 isLexCon cs = isLexConId cs || isLexConSym cs
780 isLexVar cs = isLexVarId cs || isLexVarSym cs
782 isLexId cs = isLexConId cs || isLexVarId cs
783 isLexSym cs = isLexConSym cs || isLexVarSym cs
787 isLexConId cs -- Prefix type or data constructors
788 | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
789 | cs == (fsLit "[]") = True
790 | otherwise = startsConId (headFS cs)
792 isLexVarId cs -- Ordinary prefix identifiers
793 | nullFS cs = False -- e.g. "x", "_x"
794 | otherwise = startsVarId (headFS cs)
796 isLexConSym cs -- Infix type or data constructors
797 | nullFS cs = False -- e.g. ":-:", ":", "->"
798 | cs == (fsLit "->") = True
799 | otherwise = startsConSym (headFS cs)
801 isLexVarSym cs -- Infix identifiers
802 | nullFS cs = False -- e.g. "+"
803 | otherwise = startsVarSym (headFS cs)
806 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
807 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
808 startsConSym c = c == ':' -- Infix data constructors
809 startsVarId c = isLower c || c == '_' -- Ordinary Ids
810 startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
812 isSymbolASCII :: Char -> Bool
813 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
816 %************************************************************************
819 Here rather than BinIface because OccName is abstract
821 %************************************************************************
824 instance Binary NameSpace where
827 put_ bh DataName = do
831 put_ bh TcClsName = do
836 0 -> do return VarName
837 1 -> do return DataName
838 2 -> do return TvName
839 _ -> do return TcClsName
841 instance Binary OccName where
842 put_ bh (OccName aa ab) = do
848 return (OccName aa ab)