2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 \section[Name]{@Name@: to transmit name info from renamer to typechecker}
8 -- Re-export the OccName stuff
13 mkLocalName, mkImportedLocalName, mkSysLocalName,
15 mkDerivedName, mkGlobalName, mkKnownKeyGlobal,
16 mkWiredInIdName, mkWiredInTyConName,
17 maybeWiredInIdName, maybeWiredInTyConName,
20 nameUnique, setNameUnique, setNameProvenance, getNameProvenance, setNameImportReason,
22 nameOccName, nameModule, setNameOcc, nameRdrName, setNameModule,
24 isUserExportedName, nameSrcLoc,
27 isSystemName, isLocalName, isGlobalName, isExternallyVisibleName,
31 Provenance(..), ImportReason(..), pprProvenance,
32 ExportFlag(..), PrintUnqualified,
33 pprNameProvenance, systemProvenance, hasBetterProv,
35 -- Class NamedThing and overloaded friends
37 getSrcLoc, isLocallyDefined, getOccString
40 #include "HsVersions.h"
42 import {-# SOURCE #-} Var ( Id, setIdName )
43 import {-# SOURCE #-} TyCon ( TyCon, setTyConName )
45 import OccName -- All of it
46 import Module ( Module, moduleName, pprModule, mkVanillaModule )
47 import RdrName ( RdrName, mkRdrQual, mkRdrUnqual, rdrNameOcc, rdrNameModule )
48 import CmdLineOpts ( opt_PprStyle_NoPrags, opt_OmitInterfacePragmas, opt_EnsureSplittableC )
50 import SrcLoc ( noSrcLoc, mkBuiltinSrcLoc, SrcLoc )
51 import Unique ( pprUnique, Unique, Uniquable(..) )
57 %************************************************************************
59 \subsection[Name-datatype]{The @Name@ datatype, and name construction}
61 %************************************************************************
65 n_sort :: NameSort, -- What sort of name it is
67 n_occ :: OccName, -- Its occurrence name
68 n_prov :: Provenance -- How it was made
75 | WiredInTyCon Module TyCon
78 Things with a @Global@ name are given C static labels, so they finally
79 appear in the .o file's symbol table. They appear in the symbol table
80 in the form M.n. If originally-local things have this property they
81 must be made @Global@ first.
84 mkLocalName :: Unique -> OccName -> SrcLoc -> Name
85 mkLocalName uniq occ loc = Name { n_uniq = uniq, n_sort = Local, n_occ = occ,
86 n_prov = LocalDef loc NotExported }
87 -- NB: You might worry that after lots of huffing and
88 -- puffing we might end up with two local names with distinct
89 -- uniques, but the same OccName. Indeed we can, but that's ok
90 -- * the insides of the compiler don't care: they use the Unique
91 -- * when printing for -ddump-xxx you can switch on -dppr-debug to get the
92 -- uniques if you get confused
93 -- * for interface files we tidyCore first, which puts the uniques
94 -- into the print name (see setNameVisibility below)
96 mkImportedLocalName :: Unique -> OccName -> SrcLoc -> Name
97 -- Just the same as mkLocalName, except the provenance is different
98 -- Reason: this flags the name as one that came in from an interface file.
99 -- This is useful when trying to decide which of two type variables
100 -- should 'win' when unifying them.
101 -- NB: this is only for non-top-level names, so we use ImplicitImport
102 mkImportedLocalName uniq occ loc = Name { n_uniq = uniq, n_sort = Local, n_occ = occ,
103 n_prov = NonLocalDef ImplicitImport True }
106 mkGlobalName :: Unique -> Module -> OccName -> Provenance -> Name
107 mkGlobalName uniq mod occ prov = Name { n_uniq = uniq, n_sort = Global mod,
108 n_occ = occ, n_prov = prov }
111 mkKnownKeyGlobal :: (RdrName, Unique) -> Name
112 mkKnownKeyGlobal (rdr_name, uniq)
113 = mkGlobalName uniq (mkVanillaModule (rdrNameModule rdr_name))
114 (rdrNameOcc rdr_name)
117 mkSysLocalName :: Unique -> FAST_STRING -> Name
118 mkSysLocalName uniq fs = Name { n_uniq = uniq, n_sort = Local,
119 n_occ = mkSrcVarOcc fs, n_prov = SystemProv }
121 mkTopName :: Unique -> Module -> FAST_STRING -> Name
122 -- Make a top-level name; make it Global if top-level
123 -- things should be externally visible; Local otherwise
124 -- This chap is only used *after* the tidyCore phase
125 -- Notably, it is used during STG lambda lifting
127 -- We have to make sure that the name is globally unique
128 -- and we don't have tidyCore to help us. So we append
129 -- the unique. Hack! Hack!
130 mkTopName uniq mod fs
131 = Name { n_uniq = uniq,
132 n_sort = mk_top_sort mod,
133 n_occ = mkSrcVarOcc (_PK_ ((_UNPK_ fs) ++ show uniq)),
134 n_prov = LocalDef noSrcLoc NotExported }
136 ------------------------- Wired in names -------------------------
138 mkWiredInIdName :: Unique -> Module -> OccName -> Id -> Name
139 mkWiredInIdName uniq mod occ id = Name { n_uniq = uniq, n_sort = WiredInId mod id,
140 n_occ = occ, n_prov = SystemProv }
142 -- mkWiredInTyConName takes a FAST_STRING instead of
143 -- an OccName, which is a bit yukky but that's what the
144 -- clients find easiest.
145 mkWiredInTyConName :: Unique -> Module -> FAST_STRING -> TyCon -> Name
146 mkWiredInTyConName uniq mod fs tycon
147 = Name { n_uniq = uniq, n_sort = WiredInTyCon mod tycon,
148 n_occ = mkSrcOccFS tcName fs, n_prov = SystemProv }
151 ---------------------------------------------------------------------
152 mkDerivedName :: (OccName -> OccName)
154 -> Unique -- New unique
155 -> Name -- Result is always a value name
157 mkDerivedName f name uniq = name {n_uniq = uniq, n_occ = f (n_occ name)}
159 -- When we renumber/rename things, we need to be
160 -- able to change a Name's Unique to match the cached
161 -- one in the thing it's the name of. If you know what I mean.
162 setNameUnique name uniq = name {n_uniq = uniq}
164 setNameOcc :: Name -> OccName -> Name
165 -- Give the thing a new OccName, *and*
166 -- record that it's no longer a sys-local
167 -- This is used by the tidy-up pass
168 setNameOcc name occ = name {n_occ = occ}
170 setNameModule :: Name -> Module -> Name
171 setNameModule name mod = name {n_sort = set (n_sort name)}
173 set (Global _) = Global mod
174 set (WiredInId _ id) = WiredInId mod id
175 set (WiredInTyCon _ tycon) = WiredInTyCon mod tycon
179 %************************************************************************
181 \subsection{Setting provenance and visibility
183 %************************************************************************
185 tidyTopName is applied to top-level names in the final program
187 For top-level things, it globalises Local names
188 (if all top-level things should be visible)
189 and localises non-exported Global names
190 (if only exported things should be visible)
192 In all cases except an exported global, it gives it a new occurrence name.
194 The "visibility" here concerns whether the .o file's symbol table
195 mentions the thing; if so, it needs a module name in its symbol.
196 The Global things are "visible" and the Local ones are not
198 Why should things be "visible"? Certainly they must be if they
199 are exported. But also:
201 (a) In certain (prelude only) modules we split up the .hc file into
202 lots of separate little files, which are separately compiled by the C
203 compiler. That gives lots of little .o files. The idea is that if
204 you happen to mention one of them you don't necessarily pull them all
205 in. (Pulling in a piece you don't need can be v bad, because it may
206 mention other pieces you don't need either, and so on.)
208 Sadly, splitting up .hc files means that local names (like s234) are
209 now globally visible, which can lead to clashes between two .hc
210 files. So unlocaliseWhatnot goes through making all the local things
211 into global things, essentially by giving them full names so when they
212 are printed they'll have their module name too. Pretty revolting
215 (b) When optimisation is on we want to make all the internal
216 top-level defns externally visible
219 tidyTopName :: Module -> TidyOccEnv -> Name -> (TidyOccEnv, Name)
220 tidyTopName mod env name
223 (env', occ') = tidyOccName env (n_occ name)
225 name' = Name { n_uniq = n_uniq name, n_sort = mk_top_sort mod,
226 n_occ = occ', n_prov = LocalDef noSrcLoc NotExported }
228 mk_top_sort mod | all_toplev_ids_visible = Global mod
231 all_toplev_ids_visible =
232 not opt_OmitInterfacePragmas || -- Pragmas can make them visible
233 opt_EnsureSplittableC -- Splitting requires visiblilty
237 setNameProvenance :: Name -> Provenance -> Name
238 -- setNameProvenance used to only change the provenance of
239 -- Implicit-provenance things, but that gives bad error messages
240 -- for names defined twice in the same module, so I changed it to
241 -- set the provenance of *any* global (SLPJ Jun 97)
242 setNameProvenance name prov = name {n_prov = prov}
244 getNameProvenance :: Name -> Provenance
245 getNameProvenance name = n_prov name
247 setNameImportReason :: Name -> ImportReason -> Name
248 setNameImportReason name reason
249 = name { n_prov = new_prov }
251 -- It's important that we don't do the pattern matching
252 -- in the top-level clause, else we get a black hole in
253 -- the renamer. Rather a yukky constraint. There's only
254 -- one call, in RnNames
255 old_prov = n_prov name
256 new_prov = case old_prov of
257 NonLocalDef _ omit -> NonLocalDef reason omit
262 %************************************************************************
264 \subsection{Provenance and export info}
266 %************************************************************************
270 = LocalDef -- Defined locally
272 ExportFlag -- Whether it's exported
274 | NonLocalDef -- Defined non-locally
278 | SystemProv -- Either (a) a system-generated local with
279 -- a v short name OccName
280 -- or (b) a known-key global which should have a proper
281 -- provenance attached by the renamer
284 Sys-provs are only used internally. When the compiler generates (say)
285 a fresh desguar variable it always calls it "ds", and of course it gets
286 a fresh unique. But when printing -ddump-xx dumps, we must print it with
287 its unique, because there'll be a lot of "ds" variables.
289 Names with SystemProv differ in the following ways:
290 a) locals have unique attached when printing dumps
291 b) unifier eliminates sys tyvars in favour of user provs where possible
292 c) renamer replaces SystemProv with a better one
294 Before anything gets printed in interface files or output code, it's
295 fed through a 'tidy' processor, which zaps the OccNames to have
296 unique names; and converts all sys-locals to user locals
297 If any desugarer sys-locals have survived that far, they get changed to
302 = UserImport Module SrcLoc Bool -- Imported from module M on line L
303 -- Note the M may well not be the defining module
305 -- The Bool is true iff the thing was named *explicitly* in the import spec,
306 -- rather than being imported as part of a group; e.g.
309 -- Here, everything imported by B, and the constructors of T
310 -- are not named explicitly; only T is named explicitly.
311 -- This info is used when warning of unused names.
313 | ImplicitImport -- Imported implicitly for some other reason
316 type PrintUnqualified = Bool -- True <=> the unqualified name of this thing is
317 -- in scope in this module, so print it
318 -- unqualified in error messages
320 data ExportFlag = Exported | NotExported
323 Something is "Exported" if it may be mentioned by another module without
324 warning. The crucial thing about Exported things is that they must
325 never be dropped as dead code, even if they aren't used in this module.
326 Furthermore, being Exported means that we can't see all call sites of the thing.
328 Exported things include:
330 - explicitly exported Ids, including data constructors,
331 class method selectors
333 - dfuns from instance decls
335 Being Exported is *not* the same as finally appearing in the .o file's
336 symbol table. For example, a local Id may be mentioned in an Exported
337 Id's unfolding in the interface file, in which case the local Id goes
342 systemProvenance :: Provenance
343 systemProvenance = SystemProv
345 -- pprNameProvenance is used in error messages to say where a name came from
346 pprNameProvenance :: Name -> SDoc
347 pprNameProvenance name = pprProvenance (getNameProvenance name)
349 pprProvenance :: Provenance -> SDoc
350 pprProvenance SystemProv = ptext SLIT("System")
351 pprProvenance (LocalDef loc _) = ptext SLIT("defined at") <+> ppr loc
352 pprProvenance (NonLocalDef ImplicitImport _)
353 = ptext SLIT("implicitly imported")
354 pprProvenance (NonLocalDef (UserImport mod loc _) _)
355 = ptext SLIT("imported from") <+> ppr mod <+> ptext SLIT("at") <+> ppr loc
359 %************************************************************************
361 \subsection{Predicates and selectors}
363 %************************************************************************
366 nameUnique :: Name -> Unique
367 nameOccName :: Name -> OccName
368 nameModule :: Name -> Module
369 nameSrcLoc :: Name -> SrcLoc
370 isLocallyDefinedName :: Name -> Bool
371 isUserExportedName :: Name -> Bool
372 isWiredInName :: Name -> Bool
373 isLocalName :: Name -> Bool
374 isGlobalName :: Name -> Bool
375 isExternallyVisibleName :: Name -> Bool
379 nameUnique name = n_uniq name
380 nameOccName name = n_occ name
384 Local -> pprPanic "nameModule" (ppr name)
385 x -> nameSortModule x
387 nameSortModule (Global mod) = mod
388 nameSortModule (WiredInId mod _) = mod
389 nameSortModule (WiredInTyCon mod _) = mod
391 nameRdrName :: Name -> RdrName
392 nameRdrName (Name { n_sort = Local, n_occ = occ }) = mkRdrUnqual occ
393 nameRdrName (Name { n_sort = sort, n_occ = occ }) = mkRdrQual (moduleName (nameSortModule sort)) occ
395 isUserExportedName (Name { n_prov = LocalDef _ Exported }) = True
396 isUserExportedName other = False
398 nameSrcLoc name = provSrcLoc (n_prov name)
400 provSrcLoc (LocalDef loc _) = loc
401 provSrcLoc (NonLocalDef (UserImport _ loc _) _) = loc
402 provSrcLoc other = noSrcLoc
404 isLocallyDefinedName (Name {n_sort = Local}) = True -- Local (might have SystemProv)
405 isLocallyDefinedName (Name {n_prov = LocalDef _ _}) = True -- Global, but defined here
406 isLocallyDefinedName other = False -- Other
408 -- Things the compiler "knows about" are in some sense
409 -- "imported". When we are compiling the module where
410 -- the entities are defined, we need to be able to pick
411 -- them out, often in combination with isLocallyDefined.
412 isWiredInName (Name {n_sort = WiredInTyCon _ _}) = True
413 isWiredInName (Name {n_sort = WiredInId _ _}) = True
414 isWiredInName _ = False
416 maybeWiredInIdName :: Name -> Maybe Id
417 maybeWiredInIdName (Name {n_sort = WiredInId _ id}) = Just id
418 maybeWiredInIdName other = Nothing
420 maybeWiredInTyConName :: Name -> Maybe TyCon
421 maybeWiredInTyConName (Name {n_sort = WiredInTyCon _ tc}) = Just tc
422 maybeWiredInTyConName other = Nothing
425 isLocalName (Name {n_sort = Local}) = True
426 isLocalName _ = False
428 isGlobalName (Name {n_sort = Local}) = False
429 isGlobalName other = True
431 -- Global names are by definition those that are visible
432 -- outside the module, *as seen by the linker*. Externally visible
433 -- does not mean visible at the source level (that's isExported).
434 isExternallyVisibleName name = isGlobalName name
436 hasBetterProv :: Name -> Name -> Bool
437 hasBetterProv name1 name2
438 = case n_prov name1 of
441 NonLocalDef _ _ -> case n_prov name2 of
442 LocalDef _ _ -> False
445 isSystemName (Name {n_prov = SystemProv}) = True
446 isSystemName other = False
450 %************************************************************************
452 \subsection[Name-instances]{Instance declarations}
454 %************************************************************************
457 cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2
461 instance Eq Name where
462 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
463 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
465 instance Ord Name where
466 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
467 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
468 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
469 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
470 compare a b = cmpName a b
472 instance Uniquable Name where
473 getUnique = nameUnique
475 instance NamedThing Name where
480 %************************************************************************
482 \subsection{Pretty printing}
484 %************************************************************************
487 instance Outputable Name where
488 -- When printing interfaces, all Locals have been given nice print-names
489 ppr name = pprName name
491 pprName (Name {n_sort = Local, n_uniq = uniq, n_occ = occ, n_prov = prov})
493 = getPprStyle $ \ sty ->
494 if codeStyle sty then
495 pprUnique uniq -- When printing in code we required all names to
496 -- be globally unique; for example, we use this identifier
497 -- for the closure name. So we just print the unique alone.
499 pprOccName occ <> pp_local_extra sty uniq
501 sys_local = case prov of
505 pp_local_extra sty uniq
506 | sys_local = underscore <> pprUnique uniq -- Must print uniques for sys_locals
507 | debugStyle sty = text "{-" <> pprUnique uniq <> text "-}"
511 pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ, n_prov = prov})
512 -- Globals, and wired in things
513 = getPprStyle $ \ sty ->
514 if codeStyle sty then
515 ppr mod <> underscore <> ppr occ
517 pp_mod_dot sty <> ppr occ <> pp_global_debug sty uniq prov
519 mod = nameSortModule sort
523 SystemProv -> pp_qual mod user_sty
524 -- Hack alert! Omit the qualifier on SystemProv things in user style
525 -- I claim such SystemProv things will also be WiredIn things.
526 -- We can't get the omit flag right
527 -- on wired in tycons etc (sigh) so we just leave it out in user style,
528 -- and hope that leaving it out isn't too consfusing.
529 -- (e.g. if the programmer hides Bool and redefines it. If so, use -dppr-debug.)
531 LocalDef _ _ -> pp_qual mod (user_sty || iface_sty)
533 NonLocalDef (UserImport imp_mod _ _) omit
534 | user_sty -> pp_qual imp_mod omit
535 | otherwise -> pp_qual mod False
536 NonLocalDef ImplicitImport omit -> pp_qual mod (user_sty && omit)
538 user_sty = userStyle sty
539 iface_sty = ifaceStyle sty
541 pp_qual mod omit_qual
543 | otherwise = pprModule mod <> dot
545 pp_global_debug sty uniq prov
546 | debugStyle sty = hcat [text "{-", pprUnique uniq, prov_p prov, text "-}"]
549 prov_p prov | opt_PprStyle_NoPrags = empty
550 | otherwise = comma <> pp_prov prov
552 pp_prov (LocalDef _ Exported) = char 'x'
553 pp_prov (LocalDef _ NotExported) = char 'l'
554 pp_prov (NonLocalDef ImplicitImport _) = char 'j'
555 pp_prov (NonLocalDef (UserImport _ _ True ) _) = char 'I' -- Imported by name
556 pp_prov (NonLocalDef (UserImport _ _ False) _) = char 'i' -- Imported by ..
557 pp_prov SystemProv = char 's'
561 %************************************************************************
563 \subsection{Overloaded functions related to Names}
565 %************************************************************************
568 class NamedThing a where
569 getOccName :: a -> OccName
572 getOccName n = nameOccName (getName n) -- Default method
576 getSrcLoc :: NamedThing a => a -> SrcLoc
577 isLocallyDefined :: NamedThing a => a -> Bool
578 getOccString :: NamedThing a => a -> String
580 getSrcLoc = nameSrcLoc . getName
581 isLocallyDefined = isLocallyDefinedName . getName
582 getOccString x = occNameString (getOccName x)
586 {-# SPECIALIZE isLocallyDefined :: Name -> Bool #-}