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