%
\begin{code}
-{-# OPTIONS -w #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
--- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
module OccName (
-- * The NameSpace type; abstact
NameSpace, tcName, clsName, tcClsName, dataName, varName,
startsVarSym, startsVarId, startsConSym, startsConId
) where
-#include "HsVersions.h"
-
import Util
import Unique
import BasicTypes
import UniqFM
import UniqSet
import FastString
+import FastTypes
import Outputable
import Binary
import Data.Char
-- Unicode TODO: put isSymbol in libcompat
-#if __GLASGOW_HASKELL__ > 604
+#if !defined(__GLASGOW_HASKELL__) || __GLASGOW_HASKELL__ > 604
#else
isSymbol = const False
#endif
-- The real datacon has type Int -> Int -> T
-- GHC chooses a representation based on the strictness etc.
+tcName, clsName, tcClsName :: NameSpace
+dataName, srcDataName :: NameSpace
+tvName, varName :: NameSpace
-- Though type constructors and classes are in the same name space now,
-- the NameSpace type is abstract, so we can easily separate them later
isVarName :: NameSpace -> Bool -- Variables or type variables, but not constructors
isVarName TvName = True
isVarName VarName = True
-isVarName other = False
+isVarName _ = False
pprNameSpace :: NameSpace -> SDoc
-pprNameSpace DataName = ptext SLIT("data constructor")
-pprNameSpace VarName = ptext SLIT("variable")
-pprNameSpace TvName = ptext SLIT("type variable")
-pprNameSpace TcClsName = ptext SLIT("type constructor or class")
+pprNameSpace DataName = ptext (sLit "data constructor")
+pprNameSpace VarName = ptext (sLit "variable")
+pprNameSpace TvName = ptext (sLit "type variable")
+pprNameSpace TcClsName = ptext (sLit "type constructor or class")
pprNonVarNameSpace :: NameSpace -> SDoc
pprNonVarNameSpace VarName = empty
pprNonVarNameSpace ns = pprNameSpace ns
+pprNameSpaceBrief :: NameSpace -> SDoc
pprNameSpaceBrief DataName = char 'd'
pprNameSpaceBrief VarName = char 'v'
-pprNameSpaceBrief TvName = ptext SLIT("tv")
-pprNameSpaceBrief TcClsName = ptext SLIT("tc")
+pprNameSpaceBrief TvName = ptext (sLit "tv")
+pprNameSpaceBrief TcClsName = ptext (sLit "tc")
\end{code}
\begin{code}
instance Uniquable OccName where
getUnique (OccName ns fs)
- = mkUnique char (I# (uniqueOfFS fs))
+ = mkUnique char (iBox (uniqueOfFS fs))
where -- See notes above about this getUnique function
char = case ns of
VarName -> 'i'
instance Outputable a => Outputable (OccEnv a) where
ppr (A x) = ppr x
-type OccSet = UniqFM OccName
+type OccSet = UniqSet OccName
emptyOccSet :: OccSet
unitOccSet :: OccName -> OccSet
setOccNameSpace :: NameSpace -> OccName -> OccName
setOccNameSpace sp (OccName _ occ) = OccName sp occ
-isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc :: OccName -> Bool
+isVarOcc, isTvOcc, isDataSymOcc, isSymOcc, isTcOcc, isValOcc, isDataOcc :: OccName -> Bool
isVarOcc (OccName VarName _) = True
-isVarOcc other = False
+isVarOcc _ = False
isTvOcc (OccName TvName _) = True
-isTvOcc other = False
+isTvOcc _ = False
isTcOcc (OccName TcClsName _) = True
-isTcOcc other = False
+isTcOcc _ = False
isValOcc (OccName VarName _) = True
isValOcc (OccName DataName _) = True
-isValOcc other = False
+isValOcc _ = False
-- Data constructor operator (starts with ':', or '[]')
-- Pretty inefficient!
isDataSymOcc (OccName VarName s)
| isLexConSym s = pprPanic "isDataSymOcc: check me" (ppr s)
-- Jan06: I don't think this should happen
-isDataSymOcc other = False
+isDataSymOcc _ = False
isDataOcc (OccName DataName _) = True
isDataOcc (OccName VarName s)
| isLexCon s = pprPanic "isDataOcc: check me" (ppr s)
-- Jan06: I don't think this should happen
-isDataOcc other = False
+isDataOcc _ = False
-- Any operator (data constructor or variable)
-- Pretty inefficient!
mkDataConWrapperOcc, mkWorkerOcc, mkDefaultMethodOcc, mkDerivedTyConOcc,
mkClassTyConOcc, mkClassDataConOcc, mkDictOcc, mkIPOcc,
mkSpecOcc, mkForeignExportOcc, mkGenOcc1, mkGenOcc2,
- mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc
+ mkDataTOcc, mkDataCOcc, mkDataConWorkerOcc, mkNewTyCoOcc,
+ mkInstTyCoOcc, mkEqPredCoOcc,
+ mkVectOcc, mkVectTyConOcc, mkVectDataConOcc, mkVectIsoOcc,
+ mkPArrayTyConOcc, mkPArrayDataConOcc, mkPReprTyConOcc, mkPADFunOcc
:: OccName -> OccName
-- These derived variables have a prefix that no Haskell value could have
mkPReprTyConOcc = mk_simple_deriv tcName ":VR_"
mkPADFunOcc = mk_simple_deriv varName "$PA_"
+mk_simple_deriv :: NameSpace -> String -> OccName -> OccName
mk_simple_deriv sp px occ = mk_deriv sp px (occNameString occ)
-- Data constructor workers are made by setting the name space
\begin{code}
mkMethodOcc :: OccName -> OccName
-mkMethodOcc occ@(OccName VarName fs) = occ
-mkMethodOcc occ = mk_simple_deriv varName "$m" occ
+mkMethodOcc occ@(OccName VarName _) = occ
+mkMethodOcc occ = mk_simple_deriv varName "$m" occ
\end{code}
type TidyOccEnv = OccEnv Int -- The in-scope OccNames
-- Range gives a plausible starting point for new guesses
+emptyTidyOccEnv :: TidyOccEnv
emptyTidyOccEnv = emptyOccEnv
initTidyOccEnv :: [OccName] -> TidyOccEnv -- Initialise with names to avoid!
-------------
isLexConId cs -- Prefix type or data constructors
- | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
- | cs == FSLIT("[]") = True
- | otherwise = startsConId (headFS cs)
+ | nullFS cs = False -- e.g. "Foo", "[]", "(,)"
+ | cs == (fsLit "[]") = True
+ | otherwise = startsConId (headFS cs)
isLexVarId cs -- Ordinary prefix identifiers
| nullFS cs = False -- e.g. "x", "_x"
| otherwise = startsVarId (headFS cs)
isLexConSym cs -- Infix type or data constructors
- | nullFS cs = False -- e.g. ":-:", ":", "->"
- | cs == FSLIT("->") = True
- | otherwise = startsConSym (headFS cs)
+ | nullFS cs = False -- e.g. ":-:", ":", "->"
+ | cs == (fsLit "->") = True
+ | otherwise = startsConSym (headFS cs)
isLexVarSym cs -- Infix identifiers
| nullFS cs = False -- e.g. "+"
startsVarId c = isLower c || c == '_' -- Ordinary Ids
startsConId c = isUpper c || c == '(' -- Ordinary type constructors and data constructors
+isSymbolASCII :: Char -> Bool
isSymbolASCII c = c `elem` "!#$%&*+./<=>?@\\^|~-"
\end{code}