X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FbasicTypes%2FName.lhs;h=cba20f5c7844c4e0512bf14fcb79a17f9d10b600;hb=66579ff945831c5fc9a17c58c722ff01f2268d76;hp=7dfed64a81f6ff6211531a7c07bad6080d0164c4;hpb=526c3af1dc98987b6949f4df73c0debccf9875bd;p=ghc-hetmet.git diff --git a/compiler/basicTypes/Name.lhs b/compiler/basicTypes/Name.lhs index 7dfed64..cba20f5 100644 --- a/compiler/basicTypes/Name.lhs +++ b/compiler/basicTypes/Name.lhs @@ -5,19 +5,45 @@ \section[Name]{@Name@: to transmit name info from renamer to typechecker} \begin{code} -module Name ( - -- Re-export the OccName stuff - module OccName, +-- | +-- #name_types# +-- GHC uses several kinds of name internally: +-- +-- * 'OccName.OccName': see "OccName#name_types" +-- +-- * 'RdrName.RdrName': see "RdrName#name_types" +-- +-- * 'Name.Name' is the type of names that have had their scoping and binding resolved. They +-- have an 'OccName.OccName' but also a 'Unique.Unique' that disambiguates Names that have +-- the same 'OccName.OccName' and indeed is used for all 'Name.Name' comparison. Names +-- also contain information about where they originated from, see "Name#name_sorts" +-- +-- * 'Id.Id': see "Id#name_types" +-- +-- * 'Var.Var': see "Var#name_types" +-- +-- #name_sorts# +-- Names are one of: +-- +-- * External, if they name things declared in other modules. Some external +-- Names are wired in, i.e. they name primitives defined in the compiler itself +-- +-- * Internal, if they name things in the module being compiled. Some internal +-- Names are system names, if they are names manufactured by the compiler - -- The Name type +module Name ( + -- * The main types Name, -- Abstract - BuiltInSyntax(..), + BuiltInSyntax(..), + + -- ** Creating 'Name's mkInternalName, mkSystemName, mkSystemVarName, mkSysTvName, mkFCallName, mkIPName, mkTickBoxOpName, mkExternalName, mkWiredInName, + -- ** Manipulating and deconstructing 'Name's nameUnique, setNameUnique, nameOccName, nameModule, nameModule_maybe, tidyNameOcc, @@ -25,14 +51,22 @@ module Name ( nameSrcLoc, nameSrcSpan, pprNameLoc, + -- ** Predicates on 'Name's isSystemName, isInternalName, isExternalName, - isTyVarName, isTyConName, isWiredInName, isBuiltInSyntax, + isTyVarName, isTyConName, isDataConName, + isValName, isVarName, + isWiredInName, isBuiltInSyntax, wiredInNameTyThing_maybe, nameIsLocalOrFrom, - - -- Class NamedThing and overloaded friends + + -- * Class 'NamedThing' and overloaded friends NamedThing(..), - getSrcLoc, getSrcSpan, getOccString + getSrcLoc, getSrcSpan, getOccString, + + pprInfixName, pprPrefixName, + + -- Re-export the OccName stuff + module OccName ) where import {-# SOURCE #-} TypeRep( TyThing ) @@ -43,6 +77,7 @@ import SrcLoc import Unique import Maybes import Binary +import StaticFlags import FastTypes import FastString import Outputable @@ -57,6 +92,8 @@ import Data.Array %************************************************************************ \begin{code} +-- | A unique, unambigious name for something, containing information about where +-- that thing originated. data Name = Name { n_sort :: NameSort, -- What sort of name it is n_occ :: !OccName, -- Its occurrence name @@ -81,10 +118,10 @@ data NameSort | System -- A system-defined Id or TyVar. Typically the -- OccName is very uninformative (like 's') -data BuiltInSyntax = BuiltInSyntax | UserSyntax --- BuiltInSyntax is for things like (:), [], tuples etc, --- which have special syntactic forms. They aren't "in scope" +-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples, +-- which have special syntactic forms. They aren't in scope -- as such. +data BuiltInSyntax = BuiltInSyntax | UserSyntax \end{code} Notes about the NameSorts: @@ -131,6 +168,12 @@ nameSrcLoc name = srcSpanStart (n_loc name) nameSrcSpan name = n_loc name \end{code} +%************************************************************************ +%* * +\subsection{Predicates on names} +%* * +%************************************************************************ + \begin{code} nameIsLocalOrFrom :: Module -> Name -> Bool isInternalName :: Name -> Bool @@ -171,6 +214,15 @@ isTyVarName name = isTvOcc (nameOccName name) isTyConName :: Name -> Bool isTyConName name = isTcOcc (nameOccName name) +isDataConName :: Name -> Bool +isDataConName name = isDataOcc (nameOccName name) + +isValName :: Name -> Bool +isValName name = isValOcc (nameOccName name) + +isVarName :: Name -> Bool +isVarName = isVarOcc . nameOccName + isSystemName (Name {n_sort = System}) = True isSystemName _ = False \end{code} @@ -183,6 +235,8 @@ isSystemName _ = False %************************************************************************ \begin{code} +-- | Create a name which is (for now at least) local to the current module and hence +-- does not need a 'Module' to disambiguate it from other 'Name's mkInternalName :: Unique -> OccName -> SrcSpan -> Name mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, n_occ = occ, n_loc = loc } -- NB: You might worry that after lots of huffing and @@ -194,18 +248,20 @@ mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = Inter -- * for interface files we tidyCore first, which puts the uniques -- into the print name (see setNameVisibility below) +-- | Create a name which definitely originates in the given module mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name mkExternalName uniq mod occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod, n_occ = occ, n_loc = loc } -mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax - -> Name +-- | Create a name which is actually defined by the compiler itself +mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name mkWiredInName mod occ uniq thing built_in = Name { n_uniq = getKeyFastInt uniq, n_sort = WiredIn mod thing built_in, n_occ = occ, n_loc = wiredInSrcSpan } +-- | Create a name brought into being by the compiler mkSystemName :: Unique -> OccName -> Name mkSystemName uniq occ = Name { n_uniq = getKeyFastInt uniq, n_sort = System, n_occ = occ, n_loc = noSrcSpan } @@ -216,16 +272,19 @@ mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs) mkSysTvName :: Unique -> FastString -> Name mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs) +-- | Make a name for a foreign call mkFCallName :: Unique -> String -> Name -- The encoded string completely describes the ccall mkFCallName uniq str = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, n_occ = mkVarOcc str, n_loc = noSrcSpan } + mkTickBoxOpName :: Unique -> String -> Name mkTickBoxOpName uniq str = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, n_occ = mkVarOcc str, n_loc = noSrcSpan } +-- | Make the name of an implicit parameter mkIPName :: Unique -> OccName -> Name mkIPName uniq occ = Name { n_uniq = getKeyFastInt uniq, @@ -248,14 +307,14 @@ tidyNameOcc :: Name -> OccName -> Name tidyNameOcc name@(Name { n_sort = System }) occ = name { n_occ = occ, n_sort = Internal} tidyNameOcc name occ = name { n_occ = occ } +-- | Make the 'Name' into an internal name, regardless of what it was to begin with localiseName :: Name -> Name localiseName n = n { n_sort = Internal } \end{code} - %************************************************************************ %* * -\subsection{Predicates and selectors} +\subsection{Hashing and comparison} %* * %************************************************************************ @@ -265,8 +324,10 @@ hashName name = getKey (nameUnique name) + 1 -- The +1 avoids keys with lots of zeros in the ls bits, which -- interacts badly with the cheap and cheerful multiplication in -- hashExpr -\end{code} +cmpName :: Name -> Name -> Ordering +cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2) +\end{code} %************************************************************************ %* * @@ -275,11 +336,6 @@ hashName name = getKey (nameUnique name) + 1 %************************************************************************ \begin{code} -cmpName :: Name -> Name -> Ordering -cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2) -\end{code} - -\begin{code} instance Eq Name where a == b = case (a `compare` b) of { EQ -> True; _ -> False } a /= b = case (a `compare` b) of { EQ -> False; _ -> True } @@ -363,7 +419,7 @@ pprInternal sty uniq occ | codeStyle sty = pprUnique uniq | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), pprUnique uniq]) - | dumpStyle sty = ppr_occ_name occ <> char '_' <> pprUnique uniq + | dumpStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq -- For debug dumps, we're not necessarily dumping -- tidied code, so we need to print the uniques. | otherwise = ppr_occ_name occ -- User style @@ -372,13 +428,20 @@ pprInternal sty uniq occ pprSystem :: PprStyle -> Unique -> OccName -> SDoc pprSystem sty uniq occ | codeStyle sty = pprUnique uniq - | debugStyle sty = ppr_occ_name occ <> char '_' <> pprUnique uniq + | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq <> braces (pprNameSpaceBrief (occNameSpace occ)) - | otherwise = ppr_occ_name occ <> char '_' <> pprUnique uniq + | otherwise = ppr_occ_name occ <> ppr_underscore_unique uniq -- If the tidy phase hasn't run, the OccName -- is unlikely to be informative (like 's'), -- so print the unique +ppr_underscore_unique :: Unique -> SDoc +-- Print an underscore separating the name from its unique +-- But suppress it if we aren't printing the uniques anyway +ppr_underscore_unique uniq + | opt_SuppressUniques = empty + | otherwise = char '_' <> pprUnique uniq + ppr_occ_name :: OccName -> SDoc ppr_occ_name occ = ftext (occNameFS occ) -- Don't use pprOccName; instead, just print the string of the OccName; @@ -407,6 +470,7 @@ pprNameLoc name %************************************************************************ \begin{code} +-- | A class allowing convenient access to the 'Name' of various datatypes class NamedThing a where getOccName :: a -> OccName getName :: a -> Name @@ -422,5 +486,11 @@ getOccString :: NamedThing a => a -> String getSrcLoc = nameSrcLoc . getName getSrcSpan = nameSrcSpan . getName getOccString = occNameString . getOccName + +pprInfixName, pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc +-- See Outputable.pprPrefixVar, pprInfixVar; +-- add parens or back-quotes as appropriate +pprInfixName n = pprInfixVar (isSymOcc (getOccName n)) (ppr n) +pprPrefixName n = pprPrefixVar (isSymOcc (getOccName n)) (ppr n) \end{code}