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