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