[project @ 2002-10-25 16:54:55 by simonpj]
[ghc-hetmet.git] / ghc / compiler / basicTypes / Name.lhs
1 %
2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
3 %
4 \section[Name]{@Name@: to transmit name info from renamer to typechecker}
5
6 \begin{code}
7 module Name (
8         -- Re-export the OccName stuff
9         module OccName,
10
11         -- The Name type
12         Name,                                   -- Abstract
13         mkInternalName, mkSystemName, 
14         mkSystemNameEncoded, mkSystemTvNameEncoded, mkFCallName,
15         mkIPName,
16         mkExternalName, mkKnownKeyExternalName, mkWiredInName,
17
18         nameUnique, setNameUnique,
19         nameOccName, nameModule, nameModule_maybe,
20         setNameOcc, setNameModuleAndLoc, 
21         hashName, externaliseName, localiseName,
22
23         nameSrcLoc, eqNameByOcc,
24
25         isSystemName, isInternalName, isExternalName,
26         isTyVarName, isDllName, isWiredInName,
27         nameIsLocalOrFrom, isHomePackageName,
28         
29         -- Class NamedThing and overloaded friends
30         NamedThing(..),
31         getSrcLoc, getOccString
32     ) where
33
34 #include "HsVersions.h"
35
36 import OccName          -- All of it
37 import Module           ( Module, moduleName, isHomeModule )
38 import CmdLineOpts      ( opt_Static )
39 import SrcLoc           ( noSrcLoc, isWiredInLoc, wiredInSrcLoc, SrcLoc )
40 import Unique           ( Unique, Uniquable(..), getKey, pprUnique )
41 import FastTypes
42 import Outputable
43 \end{code}
44
45 %************************************************************************
46 %*                                                                      *
47 \subsection[Name-datatype]{The @Name@ datatype, and name construction}
48 %*                                                                      *
49 %************************************************************************
50  
51 \begin{code}
52 data Name = Name {
53                 n_sort :: NameSort,     -- What sort of name it is
54                 n_occ  :: !OccName,     -- Its occurrence name
55                 n_uniq :: Unique,
56                 n_loc  :: !SrcLoc       -- Definition site
57             }
58
59 -- NOTE: we make the n_loc field strict to eliminate some potential
60 -- (and real!) space leaks, due to the fact that we don't look at
61 -- the SrcLoc in a Name all that often.
62
63 data NameSort
64   = External Module     -- (a) TyCon, Class, their derived Ids, dfun Id
65                         -- (b) Imported Id
66                         -- (c) Top-level Id in the original source, even if
67                         --      locally defined
68
69   | Internal            -- A user-defined Id or TyVar
70                         -- defined in the module being compiled
71
72   | System              -- A system-defined Id or TyVar.  Typically the
73                         -- OccName is very uninformative (like 's')
74 \end{code}
75
76 Notes about the NameSorts:
77
78 1.  Initially, top-level Ids (including locally-defined ones) get External names, 
79     and all other local Ids get Internal names
80
81 2.  Things with a External name are given C static labels, so they finally
82     appear in the .o file's symbol table.  They appear in the symbol table
83     in the form M.n.  If originally-local things have this property they
84     must be made @External@ first.
85
86 3.  In the tidy-core phase, a External that is not visible to an importer
87     is changed to Internal, and a Internal that is visible is changed to External
88
89 4.  A System Name differs in the following ways:
90         a) has unique attached when printing dumps
91         b) unifier eliminates sys tyvars in favour of user provs where possible
92
93     Before anything gets printed in interface files or output code, it's
94     fed through a 'tidy' processor, which zaps the OccNames to have
95     unique names; and converts all sys-locals to user locals
96     If any desugarer sys-locals have survived that far, they get changed to
97     "ds1", "ds2", etc.
98
99 \begin{code}
100 nameUnique              :: Name -> Unique
101 nameOccName             :: Name -> OccName 
102 nameModule              :: Name -> Module
103 nameSrcLoc              :: Name -> SrcLoc
104
105 nameUnique  name = n_uniq name
106 nameOccName name = n_occ  name
107 nameSrcLoc  name = n_loc  name
108 \end{code}
109
110 \begin{code}
111 nameIsLocalOrFrom :: Module -> Name -> Bool
112 isInternalName    :: Name -> Bool
113 isExternalName    :: Name -> Bool
114 isSystemName      :: Name -> Bool
115 isHomePackageName :: Name -> Bool
116 isWiredInName     :: Name -> Bool
117
118 isWiredInName name = isWiredInLoc (n_loc name)
119
120 isExternalName (Name {n_sort = External _}) = True
121 isExternalName other                        = False
122
123 nameModule (Name { n_sort = External mod }) = mod
124 nameModule name                             = pprPanic "nameModule" (ppr name)
125
126 nameModule_maybe (Name { n_sort = External mod }) = Just mod
127 nameModule_maybe name                             = Nothing
128
129 isInternalName name = not (isExternalName name)
130
131 nameIsLocalOrFrom from (Name {n_sort = External mod}) = mod == from
132 nameIsLocalOrFrom from other                          = True
133
134 isHomePackageName (Name {n_sort = External mod}) = isHomeModule mod
135 isHomePackageName other                          = True         -- Internal and system names
136
137 isDllName :: Name -> Bool       -- Does this name refer to something in a different DLL?
138 isDllName nm = not opt_Static && not (isHomePackageName nm)
139
140 isTyVarName :: Name -> Bool
141 isTyVarName name = isTvOcc (nameOccName name)
142
143 isSystemName (Name {n_sort = System}) = True
144 isSystemName other                    = False
145
146 eqNameByOcc :: Name -> Name -> Bool
147 -- Compare using the strings, not the unique
148 -- See notes with HsCore.eq_ufVar
149 eqNameByOcc (Name {n_sort = sort1, n_occ = occ1})
150             (Name {n_sort = sort2, n_occ = occ2})
151   = sort1 `eq_sort` sort2 && occ1 == occ2
152   where
153     eq_sort (External m1) (External m2) = moduleName m1 == moduleName m2
154     eq_sort (External _)  _             = False
155     eq_sort _            (External _)   = False
156     eq_sort _            _              = True
157 \end{code}
158
159
160 %************************************************************************
161 %*                                                                      *
162 \subsection{Making names}
163 %*                                                                      *
164 %************************************************************************
165
166 \begin{code}
167 mkInternalName :: Unique -> OccName -> SrcLoc -> Name
168 mkInternalName uniq occ loc = Name { n_uniq = uniq, n_sort = Internal, n_occ = occ, n_loc = loc }
169         -- NB: You might worry that after lots of huffing and
170         -- puffing we might end up with two local names with distinct
171         -- uniques, but the same OccName.  Indeed we can, but that's ok
172         --      * the insides of the compiler don't care: they use the Unique
173         --      * when printing for -ddump-xxx you can switch on -dppr-debug to get the
174         --        uniques if you get confused
175         --      * for interface files we tidyCore first, which puts the uniques
176         --        into the print name (see setNameVisibility below)
177
178 mkExternalName :: Unique -> Module -> OccName -> SrcLoc -> Name
179 mkExternalName uniq mod occ loc = Name { n_uniq = uniq, n_sort = External mod,
180                                          n_occ = occ, n_loc = loc }
181
182 mkKnownKeyExternalName :: Module -> OccName -> Unique -> Name
183 mkKnownKeyExternalName mod occ uniq
184   = mkExternalName uniq mod occ noSrcLoc
185
186 mkWiredInName :: Module -> OccName -> Unique -> Name
187 mkWiredInName mod occ uniq = mkExternalName uniq mod occ wiredInSrcLoc
188
189 mkSystemName :: Unique -> UserFS -> Name
190 mkSystemName uniq fs = Name { n_uniq = uniq, n_sort = System, 
191                               n_occ = mkVarOcc fs, n_loc = noSrcLoc }
192
193 -- Use this version when the string is already encoded.  Avoids duplicating
194 -- the string each time a new name is created.
195 mkSystemNameEncoded :: Unique -> EncodedFS -> Name
196 mkSystemNameEncoded uniq fs = Name { n_uniq = uniq, n_sort = System, 
197                                      n_occ = mkSysOccFS varName fs, 
198                                      n_loc = noSrcLoc }
199
200 mkSystemTvNameEncoded :: Unique -> EncodedFS -> Name
201 mkSystemTvNameEncoded uniq fs = Name { n_uniq = uniq, n_sort = System, 
202                                        n_occ = mkSysOccFS tvName fs, 
203                                        n_loc = noSrcLoc }
204
205 mkFCallName :: Unique -> EncodedString -> Name
206         -- The encoded string completely describes the ccall
207 mkFCallName uniq str =  Name { n_uniq = uniq, n_sort = Internal, 
208                                n_occ = mkFCallOcc str, n_loc = noSrcLoc }
209
210 mkIPName :: Unique -> OccName -> Name
211 mkIPName uniq occ
212   = Name { n_uniq = uniq,
213            n_sort = Internal,
214            n_occ  = occ,
215            n_loc = noSrcLoc }
216 \end{code}
217
218 \begin{code}
219 -- When we renumber/rename things, we need to be
220 -- able to change a Name's Unique to match the cached
221 -- one in the thing it's the name of.  If you know what I mean.
222 setNameUnique name uniq = name {n_uniq = uniq}
223
224 setNameOcc :: Name -> OccName -> Name
225 setNameOcc name occ = name {n_occ = occ}
226
227 externaliseName :: Name -> Module -> Name
228 externaliseName n mod = n { n_sort = External mod }
229                                 
230 localiseName :: Name -> Name
231 localiseName n = n { n_sort = Internal }
232                                 
233 setNameModuleAndLoc :: Name -> Module -> SrcLoc -> Name
234 setNameModuleAndLoc name mod loc = name {n_sort = set (n_sort name), n_loc = loc}
235                        where
236                          set (External _) = External mod
237 \end{code}
238
239
240 %************************************************************************
241 %*                                                                      *
242 \subsection{Predicates and selectors}
243 %*                                                                      *
244 %************************************************************************
245
246 \begin{code}
247 hashName :: Name -> Int
248 hashName name = iBox (getKey (nameUnique name))
249 \end{code}
250
251
252 %************************************************************************
253 %*                                                                      *
254 \subsection[Name-instances]{Instance declarations}
255 %*                                                                      *
256 %************************************************************************
257
258 \begin{code}
259 cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2
260 \end{code}
261
262 \begin{code}
263 instance Eq Name where
264     a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
265     a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
266
267 instance Ord Name where
268     a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
269     a <  b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
270     a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
271     a >  b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
272     compare a b = cmpName a b
273
274 instance Uniquable Name where
275     getUnique = nameUnique
276
277 instance NamedThing Name where
278     getName n = n
279 \end{code}
280
281
282 %************************************************************************
283 %*                                                                      *
284 \subsection{Pretty printing}
285 %*                                                                      *
286 %************************************************************************
287
288 \begin{code}
289 instance Outputable Name where
290         -- When printing interfaces, all Internals have been given nice print-names
291     ppr name = pprName name
292
293 instance OutputableBndr Name where
294     pprBndr _ name = pprName name
295
296 pprName name@(Name {n_sort = sort, n_uniq = uniq, n_occ = occ})
297   = getPprStyle $ \ sty ->
298     case sort of
299       External mod -> pprExternal sty name uniq mod occ
300       System       -> pprSystem sty uniq occ
301       Internal     -> pprInternal sty uniq occ
302
303 pprExternal sty name uniq mod occ
304   | codeStyle sty        = ppr (moduleName mod) <> char '_' <> pprOccName occ
305
306   | debugStyle sty       = ppr (moduleName mod) <> dot <> pprOccName occ <> 
307                             text "{-" <> pprUnique uniq <> text "-}"
308
309   | unqualStyle sty name = pprOccName occ
310   | otherwise            = ppr (moduleName mod) <> dot <> pprOccName occ
311
312 pprInternal sty uniq occ
313   | codeStyle sty  = pprUnique uniq
314   | debugStyle sty = pprOccName occ <> 
315                      text "{-" <> pprUnique uniq <> text "-}"
316   | otherwise      = pprOccName occ     -- User style
317
318 -- Like Internal, except that we only omit the unique in Iface style
319 pprSystem sty uniq occ
320   | codeStyle sty  = pprUnique uniq
321   | otherwise      = pprOccName occ <> char '_' <> pprUnique uniq
322                                 -- If the tidy phase hasn't run, the OccName
323                                 -- is unlikely to be informative (like 's'),
324                                 -- so print the unique
325 \end{code}
326
327 %************************************************************************
328 %*                                                                      *
329 \subsection{Overloaded functions related to Names}
330 %*                                                                      *
331 %************************************************************************
332
333 \begin{code}
334 class NamedThing a where
335     getOccName :: a -> OccName
336     getName    :: a -> Name
337
338     getOccName n = nameOccName (getName n)      -- Default method
339 \end{code}
340
341 \begin{code}
342 getSrcLoc           :: NamedThing a => a -> SrcLoc
343 getOccString        :: NamedThing a => a -> String
344
345 getSrcLoc           = nameSrcLoc           . getName
346 getOccString        = occNameString        . getOccName
347 \end{code}
348