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 module OccName (
   8         mk_deriv,
   9         -- * The NameSpace type; abstact
  10         NameSpace, tcName, clsName, tcClsName, dataName, varName,
  11         tvName, srcDataName,
  12
  13         -- ** Printing
  14         pprNameSpace, pprNonVarNameSpace, pprNameSpaceBrief,
  15
  16         -- * The OccName type
  17         OccName,        -- Abstract, instance of Outputable
  18         pprOccName,
  19
  20         -- ** Construction
  21         mkOccName, mkOccNameFS,
  22         mkVarOcc, mkVarOccFS,
  23         mkTyVarOcc,
  24         mkDFunOcc,
  25         mkTupleOcc,
  26         setOccNameSpace,
  27
  28         -- ** Derived OccNames
  29         isDerivedOccName,
  30         mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc,
  31         mkDerivedTyConOcc, mkNewTyCoOcc,
  32         mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
  33         mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
  34         mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
  35         mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc,
  36         mkSuperDictSelOcc, mkLocalOcc, mkMethodOcc, mkInstTyTcOcc,
  37         mkInstTyCoOcc, mkEqPredCoOcc,
  38         mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
  39         mkPArrayTyConOcc, mkPArrayDataConOcc,
  40         mkPReprTyConOcc,
  41         mkPADFunOcc,
  42
  43         -- ** Deconstruction
  44         occNameFS, occNameString, occNameSpace,
  45
  46         isVarOcc, isTvOcc, isTcOcc, isDataOcc, isDataSymOcc, isSymOcc, isValOcc,
  47         parenSymOcc, reportIfUnused, isTcClsName, isVarName,
  48
  49         isTupleOcc_maybe,
  50
  51         -- The OccEnv type
  52         OccEnv, emptyOccEnv, unitOccEnv, extendOccEnv, mapOccEnv,
  53         lookupOccEnv, mkOccEnv, mkOccEnv_C, extendOccEnvList, elemOccEnv,
  54         occEnvElts, foldOccEnv, plusOccEnv, plusOccEnv_C, extendOccEnv_C,
  55         filterOccEnv, delListFromOccEnv, delFromOccEnv,
  56
  57         -- The OccSet type
  58         OccSet, emptyOccSet, unitOccSet, mkOccSet, extendOccSet,
  59         extendOccSetList,
  60         unionOccSets, unionManyOccSets, minusOccSet, elemOccSet, occSetElts,
  61         foldOccSet, isEmptyOccSet, intersectOccSet, intersectsOccSet,
  62
  63         -- Tidying up
  64         TidyOccEnv, emptyTidyOccEnv, tidyOccName, initTidyOccEnv,
  65
  66         -- The basic form of names
  67         isLexCon, isLexVar, isLexId, isLexSym,
  68         isLexConId, isLexConSym, isLexVarId, isLexVarSym,
  69         startsVarSym, startsVarId, startsConSym, startsConId
  70     ) where
  71
  72 import Util
  73 import Unique
  74 import BasicTypes
  75 import StaticFlags
  76 import UniqFM
  77 import UniqSet
  78 import FastString
  79 import FastTypes
  80 import Outputable
  81 import Binary
  82
  83 import GHC.Exts
  84 import Data.Char
  85
  86 -- Unicode TODO: put isSymbol in libcompat
  87 #if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
  88 #else
  89 isSymbol :: a -> Bool
  90 isSymbol = const False
  91 #endif
  92
  93 \end{code}
  94
  95 %************************************************************************
  96 %*                                                                      *
  97 \subsection{Name space}
  98 %*                                                                      *
  99 %************************************************************************
 100
 101 \begin{code}
 102 data NameSpace = VarName        -- Variables, including "real" data constructors
 103                | DataName       -- "Source" data constructors
 104                | TvName         -- Type variables
 105                | TcClsName      -- Type constructors and classes; Haskell has them
 106                                 -- in the same name space for now.
 107                deriving( Eq, Ord )
 108    {-! derive: Binary !-}
 109
 110 -- Note [Data Constructors]
 111 -- see also: Note [Data Constructor Naming] in DataCon.lhs
 112 --
 113 --      "Source" data constructors are the data constructors mentioned
 114 --      in Haskell source code
 115 --
 116 --      "Real" data constructors are the data constructors of the
 117 --      representation type, which may not be the same as the source
 118 --      type
 119
 120 -- Example:
 121 --      data T = T !(Int,Int)
 122 --
 123 -- The source datacon has type (Int,Int) -> T
 124 -- The real   datacon has type Int -> Int -> T
 125 -- GHC chooses a representation based on the strictness etc.
 126
 127 tcName, clsName, tcClsName :: NameSpace
 128 dataName, srcDataName      :: NameSpace
 129 tvName, varName            :: NameSpace
 130
 131 -- Though type constructors and classes are in the same name space now,
 132 -- the NameSpace type is abstract, so we can easily separate them later
 133 tcName    = TcClsName           -- Type constructors
 134 clsName   = TcClsName           -- Classes
 135 tcClsName = TcClsName           -- Not sure which!
 136
 137 dataName    = DataName
 138 srcDataName = DataName  -- Haskell-source data constructors should be
 139                         -- in the Data name space
 140
 141 tvName      = TvName
 142 varName     = VarName
 143
 144 isTcClsName :: NameSpace -> Bool
 145 isTcClsName TcClsName = True
 146 isTcClsName _         = False
 147
 148 isVarName :: NameSpace -> Bool  -- Variables or type variables, but not constructors
 149 isVarName TvName  = True
 150 isVarName VarName = True
 151 isVarName _       = False
 152
 153 pprNameSpace :: NameSpace -> SDoc
 154 pprNameSpace DataName  = ptext (sLit "data constructor")
 155 pprNameSpace VarName   = ptext (sLit "variable")
 156 pprNameSpace TvName    = ptext (sLit "type variable")
 157 pprNameSpace TcClsName = ptext (sLit "type constructor or class")
 158
 159 pprNonVarNameSpace :: NameSpace -> SDoc
 160 pprNonVarNameSpace VarName = empty
 161 pprNonVarNameSpace ns = pprNameSpace ns
 162
 163 pprNameSpaceBrief :: NameSpace -> SDoc
 164 pprNameSpaceBrief DataName  = char 'd'
 165 pprNameSpaceBrief VarName   = char 'v'
 166 pprNameSpaceBrief TvName    = ptext (sLit "tv")
 167 pprNameSpaceBrief TcClsName = ptext (sLit "tc")
 168 \end{code}
 169
 170
 171 %************************************************************************
 172 %*                                                                      *
 173 \subsection[Name-pieces-datatypes]{The @OccName@ datatypes}
 174 %*                                                                      *
 175 %************************************************************************
 176
 177 \begin{code}
 178 data OccName = OccName
 179     { occNameSpace  :: !NameSpace
 180     , occNameFS     :: !FastString
 181     }
 182 \end{code}
 183
 184
 185 \begin{code}
 186 instance Eq OccName where
 187     (OccName sp1 s1) == (OccName sp2 s2) = s1 == s2 && sp1 == sp2
 188
 189 instance Ord OccName where
 190         -- Compares lexicographically, *not* by Unique of the string
 191     compare (OccName sp1 s1) (OccName sp2 s2)
 192         = (s1  `compare` s2) `thenCmp` (sp1 `compare` sp2)
 193 \end{code}
 194
 195
 196 %************************************************************************
 197 %*                                                                      *
 198 \subsection{Printing}
 199 %*                                                                      *
 200 %************************************************************************
 201
 202 \begin{code}
 203 instance Outputable OccName where
 204     ppr = pprOccName
 205
 206 pprOccName :: OccName -> SDoc
 207 pprOccName (OccName sp occ)
 208   = getPprStyle $ \ sty ->
 209     if codeStyle sty
 210         then ftext (zEncodeFS occ)
 211         else ftext occ <> if debugStyle sty
 212                             then braces (pprNameSpaceBrief sp)
 213                             else empty
 214 \end{code}
 215
 216
 217 %************************************************************************
 218 %*                                                                      *
 219 \subsection{Construction}
 220 %*                                                                      *
 221 %************************************************************************
 222
 223 \begin{code}
 224 mkOccName :: NameSpace -> String -> OccName
 225 mkOccName occ_sp str = OccName occ_sp (mkFastString str)
 226
 227 mkOccNameFS :: NameSpace -> FastString -> OccName
 228 mkOccNameFS occ_sp fs = OccName occ_sp fs
 229
 230 mkVarOcc :: String -> OccName
 231 mkVarOcc s = mkOccName varName s
 232
 233 mkVarOccFS :: FastString -> OccName
 234 mkVarOccFS fs = mkOccNameFS varName fs
 235
 236 mkTyVarOcc :: FastString -> OccName
 237 mkTyVarOcc fs = mkOccNameFS tvName fs
 238 \end{code}
 239
 240
 241 %************************************************************************
 242 %*                                                                      *
 243                 Environments
 244 %*                                                                      *
 245 %************************************************************************
 246
 247 OccEnvs are used mainly for the envts in ModIfaces.
 248
 249 They are efficient, because FastStrings have unique Int# keys.  We assume
 250 this key is less than 2^24, so we can make a Unique using
 251         mkUnique ns key  :: Unique
 252 where 'ns' is a Char reprsenting the name space.  This in turn makes it
 253 easy to build an OccEnv.
 254
 255 \begin{code}
 256 instance Uniquable OccName where
 257   getUnique (OccName ns fs)
 258       = mkUnique char (iBox (uniqueOfFS fs))
 259       where     -- See notes above about this getUnique function
 260         char = case ns of
 261                 VarName   -> 'i'
 262                 DataName  -> 'd'
 263                 TvName    -> 'v'
 264                 TcClsName -> 't'
 265
 266 newtype OccEnv a = A (UniqFM a)
 267
 268 emptyOccEnv :: OccEnv a
 269 unitOccEnv  :: OccName -> a -> OccEnv a
 270 extendOccEnv :: OccEnv a -> OccName -> a -> OccEnv a
 271 extendOccEnvList :: OccEnv a -> [(OccName, a)] -> OccEnv a
 272 lookupOccEnv :: OccEnv a -> OccName -> Maybe a
 273 mkOccEnv     :: [(OccName,a)] -> OccEnv a
 274 mkOccEnv_C   :: (a -> a -> a) -> [(OccName,a)] -> OccEnv a
 275 elemOccEnv   :: OccName -> OccEnv a -> Bool
 276 foldOccEnv   :: (a -> b -> b) -> b -> OccEnv a -> b
 277 occEnvElts   :: OccEnv a -> [a]
 278 extendOccEnv_C :: (a->a->a) -> OccEnv a -> OccName -> a -> OccEnv a
 279 plusOccEnv     :: OccEnv a -> OccEnv a -> OccEnv a
 280 plusOccEnv_C   :: (a->a->a) -> OccEnv a -> OccEnv a -> OccEnv a
 281 mapOccEnv      :: (a->b) -> OccEnv a -> OccEnv b
 282 delFromOccEnv      :: OccEnv a -> OccName -> OccEnv a
 283 delListFromOccEnv :: OccEnv a -> [OccName] -> OccEnv a
 284 filterOccEnv       :: (elt -> Bool) -> OccEnv elt -> OccEnv elt
 285
 286 emptyOccEnv      = A emptyUFM
 287 unitOccEnv x y = A $ unitUFM x y
 288 extendOccEnv (A x) y z = A $ addToUFM x y z
 289 extendOccEnvList (A x) l = A $ addListToUFM x l
 290 lookupOccEnv (A x) y = lookupUFM x y
 291 mkOccEnv     l    = A $ listToUFM l
 292 elemOccEnv x (A y)       = elemUFM x y
 293 foldOccEnv a b (A c)     = foldUFM a b c
 294 occEnvElts (A x)         = eltsUFM x
 295 plusOccEnv (A x) (A y)   = A $ plusUFM x y
 296 plusOccEnv_C f (A x) (A y)       = A $ plusUFM_C f x y
 297 extendOccEnv_C f (A x) y z   = A $ addToUFM_C f x y z
 298 mapOccEnv f (A x)        = A $ mapUFM f x
 299 mkOccEnv_C comb l = A $ addListToUFM_C comb emptyUFM l
 300 delFromOccEnv (A x) y    = A $ delFromUFM x y
 301 delListFromOccEnv (A x) y  = A $ delListFromUFM x y
 302 filterOccEnv x (A y)       = A $ filterUFM x y
 303
 304 instance Outputable a => Outputable (OccEnv a) where
 305     ppr (A x) = ppr x
 306
 307 type OccSet = UniqSet OccName
 308
 309 emptyOccSet       :: OccSet
 310 unitOccSet        :: OccName -> OccSet
 311 mkOccSet          :: [OccName] -> OccSet
 312 extendOccSet      :: OccSet -> OccName -> OccSet
 313 extendOccSetList  :: OccSet -> [OccName] -> OccSet
 314 unionOccSets      :: OccSet -> OccSet -> OccSet
 315 unionManyOccSets  :: [OccSet] -> OccSet
 316 minusOccSet       :: OccSet -> OccSet -> OccSet
 317 elemOccSet        :: OccName -> OccSet -> Bool
 318 occSetElts        :: OccSet -> [OccName]
 319 foldOccSet        :: (OccName -> b -> b) -> b -> OccSet -> b
 320 isEmptyOccSet     :: OccSet -> Bool
 321 intersectOccSet   :: OccSet -> OccSet -> OccSet
 322 intersectsOccSet  :: OccSet -> OccSet -> Bool
 323
 324 emptyOccSet       = emptyUniqSet
 325 unitOccSet        = unitUniqSet
 326 mkOccSet          = mkUniqSet
 327 extendOccSet      = addOneToUniqSet
 328 extendOccSetList  = addListToUniqSet
 329 unionOccSets      = unionUniqSets
 330 unionManyOccSets  = unionManyUniqSets
 331 minusOccSet       = minusUniqSet
 332 elemOccSet        = elementOfUniqSet
 333 occSetElts        = uniqSetToList
 334 foldOccSet        = foldUniqSet
 335 isEmptyOccSet     = isEmptyUniqSet
 336 intersectOccSet   = intersectUniqSets
 337 intersectsOccSet s1 s2 = not (isEmptyOccSet (s1 `intersectOccSet` s2))
 338 \end{code}
 339
 340
 341 %************************************************************************
 342 %*                                                                      *
 343 \subsection{Predicates and taking them apart}
 344 %*                                                                      *
 345 %************************************************************************
 346
 347 \begin{code}
 348 occNameString :: OccName -> String
 349 occNameString (OccName _ s) = unpackFS s
 350
 351 setOccNameSpace :: NameSpace -> OccName -> OccName
 352 setOccNameSpace sp (OccName _ occ) = OccName sp occ
 353
 354 isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc, isValOcc, isDataOcc :: OccName -> Bool
 355
 356 isVarOcc (OccName VarName _) = True
 357 isVarOcc _                   = False
 358
 359 isTvOcc (OccName TvName _) = True
 360 isTvOcc _                  = False
 361
 362 isTcOcc (OccName TcClsName _) = True
 363 isTcOcc _                     = False
 364
 365 isValOcc (OccName VarName  _) = True
 366 isValOcc (OccName DataName _) = True
 367 isValOcc _                    = False
 368
 369 -- Data constructor operator (starts with ':', or '[]')
 370 -- Pretty inefficient!
 371 isDataSymOcc (OccName DataName s) = isLexConSym s
 372 isDataSymOcc (OccName VarName s)
 373   | isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
 374                 -- Jan06: I don't think this should happen
 375 isDataSymOcc _                    = False
 376
 377 isDataOcc (OccName DataName _) = True
 378 isDataOcc (OccName VarName s)
 379   | isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
 380                 -- Jan06: I don't think this should happen
 381 isDataOcc _                    = False
 382
 383 -- Any operator (data constructor or variable)
 384 -- Pretty inefficient!
 385 isSymOcc (OccName DataName s)  = isLexConSym s
 386 isSymOcc (OccName TcClsName s) = isLexConSym s
 387 isSymOcc (OccName VarName s)   = isLexSym s
 388 isSymOcc (OccName TvName s)    = isLexSym s
 389
 390 parenSymOcc :: OccName -> SDoc -> SDoc
 391 -- Wrap parens around an operator
 392 parenSymOcc occ doc | isSymOcc occ = parens doc
 393                     | otherwise    = doc
 394 \end{code}
 395
 396
 397 \begin{code}
 398 reportIfUnused :: OccName -> Bool
 399   -- Haskell 98 encourages compilers to suppress warnings about
 400   -- unused names in a pattern if they start with "_".
 401 reportIfUnused occ = case occNameString occ of
 402                         ('_' : _) -> False
 403                         _other    -> True
 404 \end{code}
 405
 406
 407 %************************************************************************
 408 %*                                                                      *
 409 \subsection{Making system names}
 410 %*                                                                      *
 411 %************************************************************************
 412
 413 Here's our convention for splitting up the interface file name space:
 414
 415         d...            dictionary identifiers
 416                         (local variables, so no name-clash worries)
 417
 418         $f...           dict-fun identifiers (from inst decls)
 419         $dm...          default methods
 420         $p...           superclass selectors
 421         $w...           workers
 422         :T...           compiler-generated tycons for dictionaries
 423         :D...           ...ditto data cons
 424         :Co...          ...ditto coercions
 425         $sf..           specialised version of f
 426
 427         in encoded form these appear as Zdfxxx etc
 428
 429         :...            keywords (export:, letrec: etc.)
 430 --- I THINK THIS IS WRONG!
 431
 432 This knowledge is encoded in the following functions.
 433
 434 @mk_deriv@ generates an @OccName@ from the prefix and a string.
 435 NB: The string must already be encoded!
 436
 437 \begin{code}
 438 mk_deriv :: NameSpace
 439          -> String              -- Distinguishes one sort of derived name from another
 440          -> String
 441          -> OccName
 442
 443 mk_deriv occ_sp sys_prefix str = mkOccName occ_sp (sys_prefix ++ str)
 444
 445 isDerivedOccName :: OccName -> Bool
 446 isDerivedOccName occ =
 447    case occNameString occ of
 448      '$':c:_ | isAlphaNum c -> True
 449      ':':c:_ | isAlphaNum c -> True
 450      _other                 -> False
 451 \end{code}
 452
 453 \begin{code}
 454 mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
 455         mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
 456         mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
 457         mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
 458         mkInstTyCoOcc, mkEqPredCoOcc,
 459         mkCon2TagOcc, mkTag2ConOcc, mkMaxTagOcc,
 460         mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
 461         mkPArrayTyConOcc, mkPArrayDataConOcc, mkPReprTyConOcc, mkPADFunOcc
 462    :: OccName -> OccName
 463
 464 -- These derived variables have a prefix that no Haskell value could have
 465 mkDataConWrapperOcc = mk_simple_deriv varName  "$W"
 466 mkWorkerOcc         = mk_simple_deriv varName  "$w"
 467 mkDefaultMethodOcc  = mk_simple_deriv varName  "$dm"
 468 mkDerivedTyConOcc   = mk_simple_deriv tcName   ":"      -- The : prefix makes sure it classifies
 469 mkClassTyConOcc     = mk_simple_deriv tcName   ":T"     -- as a tycon/datacon
 470 mkClassDataConOcc   = mk_simple_deriv dataName ":D"     -- We go straight to the "real" data con
 471                                                         -- for datacons from classes
 472 mkDictOcc           = mk_simple_deriv varName  "$d"
 473 mkIPOcc             = mk_simple_deriv varName  "$i"
 474 mkSpecOcc           = mk_simple_deriv varName  "$s"
 475 mkForeignExportOcc  = mk_simple_deriv varName  "$f"
 476 mkNewTyCoOcc        = mk_simple_deriv tcName  ":Co"
 477 mkInstTyCoOcc       = mk_simple_deriv tcName  ":CoF"     -- derived from rep ty
 478 mkEqPredCoOcc       = mk_simple_deriv tcName  "$co"
 479
 480 -- used in derived instances
 481 mkCon2TagOcc        = mk_simple_deriv varName  "$con2tag_"
 482 mkTag2ConOcc        = mk_simple_deriv varName  "$tag2con_"
 483 mkMaxTagOcc         = mk_simple_deriv varName  "$maxtag_"
 484
 485 -- Generic derivable classes
 486 mkGenOcc1           = mk_simple_deriv varName  "$gfrom"
 487 mkGenOcc2           = mk_simple_deriv varName  "$gto"
 488
 489 -- data T = MkT ... deriving( Data ) needs defintions for
 490 --      $tT   :: Data.Generics.Basics.DataType
 491 --      $cMkT :: Data.Generics.Basics.Constr
 492 mkDataTOcc = mk_simple_deriv varName  "$t"
 493 mkDataCOcc = mk_simple_deriv varName  "$c"
 494
 495 -- Vectorisation
 496 mkVectOcc          = mk_simple_deriv varName  "$v_"
 497 mkVectTyConOcc     = mk_simple_deriv tcName   ":V_"
 498 mkVectDataConOcc   = mk_simple_deriv dataName ":VD_"
 499 mkVectIsoOcc       = mk_simple_deriv varName  "$VI_"
 500 mkPArrayTyConOcc   = mk_simple_deriv tcName   ":VP_"
 501 mkPArrayDataConOcc = mk_simple_deriv dataName ":VPD_"
 502 mkPReprTyConOcc    = mk_simple_deriv tcName   ":VR_"
 503 mkPADFunOcc        = mk_simple_deriv varName  "$PA_"
 504
 505 mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
 506 mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
 507
 508 -- Data constructor workers are made by setting the name space
 509 -- of the data constructor OccName (which should be a DataName)
 510 -- to VarName
 511 mkDataConWorkerOcc datacon_occ = setOccNameSpace varName datacon_occ
 512 \end{code}
 513
 514 \begin{code}
 515 mkSuperDictSelOcc :: Int        -- Index of superclass, eg 3
 516                   -> OccName    -- Class, eg "Ord"
 517                   -> OccName    -- eg "$p3Ord"
 518 mkSuperDictSelOcc index cls_occ
 519   = mk_deriv varName "$p" (show index ++ occNameString cls_occ)
 520
 521 mkLocalOcc :: Unique            -- Unique
 522            -> OccName           -- Local name (e.g. "sat")
 523            -> OccName           -- Nice unique version ("$L23sat")
 524 mkLocalOcc uniq occ
 525    = mk_deriv varName ("$L" ++ show uniq) (occNameString occ)
 526         -- The Unique might print with characters
 527         -- that need encoding (e.g. 'z'!)
 528 \end{code}
 529
 530 Derive a name for the representation type constructor of a data/newtype
 531 instance.
 532
 533 \begin{code}
 534 mkInstTyTcOcc :: Int                    -- Index
 535               -> OccName                -- Family name (e.g. "Map")
 536               -> OccName                -- Nice unique version (":R23Map")
 537 mkInstTyTcOcc index occ
 538    = mk_deriv tcName (":R" ++ show index) (occNameString occ)
 539 \end{code}
 540
 541 \begin{code}
 542 mkDFunOcc :: String             -- Typically the class and type glommed together e.g. "OrdMaybe"
 543                                 -- Only used in debug mode, for extra clarity
 544           -> Bool               -- True <=> hs-boot instance dfun
 545           -> Int                -- Unique index
 546           -> OccName            -- "$f3OrdMaybe"
 547
 548 -- In hs-boot files we make dict funs like $fx7ClsTy, which get bound to the real
 549 -- thing when we compile the mother module. Reason: we don't know exactly
 550 -- what the  mother module will call it.
 551
 552 mkDFunOcc info_str is_boot index
 553   = mk_deriv VarName prefix string
 554   where
 555     prefix | is_boot   = "$fx"
 556            | otherwise = "$f"
 557     string | opt_PprStyle_Debug = show index ++ info_str
 558            | otherwise          = show index
 559 \end{code}
 560
 561 We used to add a '$m' to indicate a method, but that gives rise to bad
 562 error messages from the type checker when we print the function name or pattern
 563 of an instance-decl binding.  Why? Because the binding is zapped
 564 to use the method name in place of the selector name.
 565 (See TcClassDcl.tcMethodBind)
 566
 567 The way it is now, -ddump-xx output may look confusing, but
 568 you can always say -dppr-debug to get the uniques.
 569
 570 However, we *do* have to zap the first character to be lower case,
 571 because overloaded constructors (blarg) generate methods too.
 572 And convert to VarName space
 573
 574 e.g. a call to constructor MkFoo where
 575         data (Ord a) => Foo a = MkFoo a
 576
 577 If this is necessary, we do it by prefixing '$m'.  These
 578 guys never show up in error messages.  What a hack.
 579
 580 \begin{code}
 581 mkMethodOcc :: OccName -> OccName
 582 mkMethodOcc occ@(OccName VarName _) = occ
 583 mkMethodOcc occ                     = mk_simple_deriv varName "$m" occ
 584 \end{code}
 585
 586
 587 %************************************************************************
 588 %*                                                                      *
 589 \subsection{Tidying them up}
 590 %*                                                                      *
 591 %************************************************************************
 592
 593 Before we print chunks of code we like to rename it so that
 594 we don't have to print lots of silly uniques in it.  But we mustn't
 595 accidentally introduce name clashes!  So the idea is that we leave the
 596 OccName alone unless it accidentally clashes with one that is already
 597 in scope; if so, we tack on '1' at the end and try again, then '2', and
 598 so on till we find a unique one.
 599
 600 There's a wrinkle for operators.  Consider '>>='.  We can't use '>>=1'
 601 because that isn't a single lexeme.  So we encode it to 'lle' and *then*
 602 tack on the '1', if necessary.
 603
 604 \begin{code}
 605 type TidyOccEnv = OccEnv Int    -- The in-scope OccNames
 606         -- Range gives a plausible starting point for new guesses
 607
 608 emptyTidyOccEnv :: TidyOccEnv
 609 emptyTidyOccEnv = emptyOccEnv
 610
 611 initTidyOccEnv :: [OccName] -> TidyOccEnv       -- Initialise with names to avoid!
 612 initTidyOccEnv = foldl (\env occ -> extendOccEnv env occ 1) emptyTidyOccEnv
 613
 614 tidyOccName :: TidyOccEnv -> OccName -> (TidyOccEnv, OccName)
 615
 616 tidyOccName in_scope occ@(OccName occ_sp fs)
 617   = case lookupOccEnv in_scope occ of
 618         Nothing ->      -- Not already used: make it used
 619                    (extendOccEnv in_scope occ 1, occ)
 620
 621         Just n  ->      -- Already used: make a new guess,
 622                         -- change the guess base, and try again
 623                    tidyOccName  (extendOccEnv in_scope occ (n+1))
 624                                 (mkOccName occ_sp (unpackFS fs ++ show n))
 625 \end{code}
 626
 627 %************************************************************************
 628 %*                                                                      *
 629                 Stuff for dealing with tuples
 630 %*                                                                      *
 631 %************************************************************************
 632
 633 \begin{code}
 634 mkTupleOcc :: NameSpace -> Boxity -> Arity -> OccName
 635 mkTupleOcc ns bx ar = OccName ns (mkFastString str)
 636   where
 637         -- no need to cache these, the caching is done in the caller
 638         -- (TysWiredIn.mk_tuple)
 639     str = case bx of
 640                 Boxed   -> '(' : commas ++ ")"
 641                 Unboxed -> '(' : '#' : commas ++ "#)"
 642
 643     commas = take (ar-1) (repeat ',')
 644
 645 isTupleOcc_maybe :: OccName -> Maybe (NameSpace, Boxity, Arity)
 646 -- Tuples are special, because there are so many of them!
 647 isTupleOcc_maybe (OccName ns fs)
 648   = case unpackFS fs of
 649         '(':'#':',':rest -> Just (ns, Unboxed, 2 + count_commas rest)
 650         '(':',':rest     -> Just (ns, Boxed,   2 + count_commas rest)
 651         _other           -> Nothing
 652   where
 653     count_commas (',':rest) = 1 + count_commas rest
 654     count_commas _          = 0
 655 \end{code}
 656
 657 %************************************************************************
 658 %*                                                                      *
 659 \subsection{Lexical categories}
 660 %*                                                                      *
 661 %************************************************************************
 662
 663 These functions test strings to see if they fit the lexical categories
 664 defined in the Haskell report.
 665
 666 \begin{code}
 667 isLexCon,   isLexVar,    isLexId,    isLexSym    :: FastString -> Bool
 668 isLexConId, isLexConSym, isLexVarId, isLexVarSym :: FastString -> Bool
 669
 670 isLexCon cs = isLexConId  cs || isLexConSym cs
 671 isLexVar cs = isLexVarId  cs || isLexVarSym cs
 672
 673 isLexId  cs = isLexConId  cs || isLexVarId  cs
 674 isLexSym cs = isLexConSym cs || isLexVarSym cs
 675
 676 -------------
 677
 678 isLexConId cs                           -- Prefix type or data constructors
 679   | nullFS cs          = False          --      e.g. "Foo", "[]", "(,)"
 680   | cs == (fsLit "[]") = True
 681   | otherwise          = startsConId (headFS cs)
 682
 683 isLexVarId cs                           -- Ordinary prefix identifiers
 684   | nullFS cs         = False           --      e.g. "x", "_x"
 685   | otherwise         = startsVarId (headFS cs)
 686
 687 isLexConSym cs                          -- Infix type or data constructors
 688   | nullFS cs          = False          --      e.g. ":-:", ":", "->"
 689   | cs == (fsLit "->") = True
 690   | otherwise          = startsConSym (headFS cs)
 691
 692 isLexVarSym cs                          -- Infix identifiers
 693   | nullFS cs         = False           --      e.g. "+"
 694   | otherwise         = startsVarSym (headFS cs)
 695
 696 -------------
 697 startsVarSym, startsVarId, startsConSym, startsConId :: Char -> Bool
 698 startsVarSym c = isSymbolASCII c || (ord c > 0x7f && isSymbol c) -- Infix Ids
 699 startsConSym c = c == ':'                               -- Infix data constructors
 700 startsVarId c  = isLower c || c == '_'  -- Ordinary Ids
 701 startsConId c  = isUpper c || c == '('  -- Ordinary type constructors and data constructors
 702
 703 isSymbolASCII :: Char -> Bool
 704 isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
 705 \end{code}
 706
 707 %************************************************************************
 708 %*                                                                      *
 709                 Binary instance
 710     Here rather than BinIface because OccName is abstract
 711 %*                                                                      *
 712 %************************************************************************
 713
 714 \begin{code}
 715 instance Binary NameSpace where
 716     put_ bh VarName = do
 717             putByte bh 0
 718     put_ bh DataName = do
 719             putByte bh 1
 720     put_ bh TvName = do
 721             putByte bh 2
 722     put_ bh TcClsName = do
 723             putByte bh 3
 724     get bh = do
 725             h <- getByte bh
 726             case h of
 727               0 -> do return VarName
 728               1 -> do return DataName
 729               2 -> do return TvName
 730               _ -> do return TcClsName
 731
 732 instance Binary OccName where
 733     put_ bh (OccName aa ab) = do
 734             put_ bh aa
 735             put_ bh ab
 736     get bh = do
 737           aa <- get bh
 738           ab <- get bh
 739           return (OccName aa ab)
 740 \end{code}