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