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, mkCCallName,
15 mkDerivedName, mkGlobalName, mkKnownKeyGlobal,
16 mkWiredInIdName, mkWiredInTyConName,
17 mkUnboundName, isUnboundName,
19 maybeWiredInIdName, maybeWiredInTyConName,
20 isWiredInName, hashName,
22 nameUnique, setNameUnique, setNameProvenance, getNameProvenance, setNameImportReason,
24 nameOccName, nameModule, setNameOcc, nameRdrName, setNameModule, toRdrName,
26 isUserExportedName, isUserImportedName, isUserImportedExplicitlyName,
27 maybeUserImportedFrom,
28 nameSrcLoc, isLocallyDefinedName, isDllName,
30 isSystemName, isLocalName, isGlobalName, isExternallyVisibleName,
34 emptyNameEnv, unitNameEnv, nameEnvElts,
35 extendNameEnv_C, extendNameEnv,
36 plusNameEnv, plusNameEnv_C, extendNameEnv, extendNameEnvList,
37 lookupNameEnv, lookupNameEnv_NF, delFromNameEnv, elemNameEnv,
41 Provenance(..), ImportReason(..), pprProvenance,
42 ExportFlag(..), PrintUnqualified,
43 pprNameProvenance, hasBetterProv,
45 -- Class NamedThing and overloaded friends
47 getSrcLoc, isLocallyDefined, getOccString, toRdrName
50 #include "HsVersions.h"
52 import {-# SOURCE #-} Var ( Id, setIdName )
53 import {-# SOURCE #-} TyCon ( TyCon, setTyConName )
55 import OccName -- All of it
56 import Module ( Module, moduleName, pprModule, mkVanillaModule, isLocalModule )
57 import RdrName ( RdrName, mkRdrQual, mkRdrUnqual, rdrNameOcc, rdrNameModule )
58 import CmdLineOpts ( opt_Static, opt_PprStyle_NoPrags, opt_OmitInterfacePragmas, opt_EnsureSplittableC )
60 import SrcLoc ( noSrcLoc, mkBuiltinSrcLoc, SrcLoc )
61 import Unique ( pprUnique, Unique, Uniquable(..), hasKey, unboundKey, u2i )
62 import Maybes ( expectJust )
69 %************************************************************************
71 \subsection[Name-datatype]{The @Name@ datatype, and name construction}
73 %************************************************************************
77 n_sort :: NameSort, -- What sort of name it is
79 n_occ :: OccName, -- Its occurrence name
80 n_prov :: Provenance -- How it was made
87 | WiredInTyCon Module TyCon
90 Things with a @Global@ name are given C static labels, so they finally
91 appear in the .o file's symbol table. They appear in the symbol table
92 in the form M.n. If originally-local things have this property they
93 must be made @Global@ first.
96 mkLocalName :: Unique -> OccName -> SrcLoc -> Name
97 mkLocalName uniq occ loc = Name { n_uniq = uniq, n_sort = Local, n_occ = occ,
98 n_prov = LocalDef loc NotExported }
99 -- NB: You might worry that after lots of huffing and
100 -- puffing we might end up with two local names with distinct
101 -- uniques, but the same OccName. Indeed we can, but that's ok
102 -- * the insides of the compiler don't care: they use the Unique
103 -- * when printing for -ddump-xxx you can switch on -dppr-debug to get the
104 -- uniques if you get confused
105 -- * for interface files we tidyCore first, which puts the uniques
106 -- into the print name (see setNameVisibility below)
108 mkImportedLocalName :: Unique -> OccName -> SrcLoc -> Name
109 -- Just the same as mkLocalName, except the provenance is different
110 -- Reason: this flags the name as one that came in from an interface file.
111 -- This is useful when trying to decide which of two type variables
112 -- should 'win' when unifying them.
113 -- NB: this is only for non-top-level names, so we use ImplicitImport
114 mkImportedLocalName uniq occ loc = Name { n_uniq = uniq, n_sort = Local, n_occ = occ,
115 n_prov = NonLocalDef ImplicitImport True }
118 mkGlobalName :: Unique -> Module -> OccName -> Provenance -> Name
119 mkGlobalName uniq mod occ prov = Name { n_uniq = uniq, n_sort = Global mod,
120 n_occ = occ, n_prov = prov }
123 mkKnownKeyGlobal :: (RdrName, Unique) -> Name
124 mkKnownKeyGlobal (rdr_name, uniq)
125 = mkGlobalName uniq (mkVanillaModule (rdrNameModule rdr_name))
126 (rdrNameOcc rdr_name)
129 mkSysLocalName :: Unique -> UserFS -> Name
130 mkSysLocalName uniq fs = Name { n_uniq = uniq, n_sort = Local,
131 n_occ = mkSrcVarOcc fs, n_prov = systemProvenance }
133 mkCCallName :: Unique -> EncodedString -> Name
134 -- The encoded string completely describes the ccall
135 mkCCallName uniq str = Name { n_uniq = uniq, n_sort = Local,
136 n_occ = mkCCallOcc str,
137 n_prov = NonLocalDef ImplicitImport True }
139 mkTopName :: Unique -> Module -> FAST_STRING -> Name
140 -- Make a top-level name; make it Global if top-level
141 -- things should be externally visible; Local otherwise
142 -- This chap is only used *after* the tidyCore phase
143 -- Notably, it is used during STG lambda lifting
145 -- We have to make sure that the name is globally unique
146 -- and we don't have tidyCore to help us. So we append
147 -- the unique. Hack! Hack!
148 mkTopName uniq mod fs
149 = Name { n_uniq = uniq,
150 n_sort = mk_top_sort mod,
151 n_occ = mkSrcVarOcc (_PK_ ((_UNPK_ fs) ++ show uniq)),
152 n_prov = LocalDef noSrcLoc NotExported }
154 mkIPName :: Unique -> OccName -> Name
156 = Name { n_uniq = uniq,
159 -- ZZ is this an appropriate provinence?
160 n_prov = SystemProv }
162 ------------------------- Wired in names -------------------------
164 mkWiredInIdName :: Unique -> Module -> OccName -> Id -> Name
165 mkWiredInIdName uniq mod occ id = Name { n_uniq = uniq, n_sort = WiredInId mod id,
166 n_occ = occ, n_prov = SystemProv }
168 -- mkWiredInTyConName takes a FAST_STRING instead of
169 -- an OccName, which is a bit yukky but that's what the
170 -- clients find easiest.
171 mkWiredInTyConName :: Unique -> Module -> FAST_STRING -> TyCon -> Name
172 mkWiredInTyConName uniq mod fs tycon
173 = Name { n_uniq = uniq, n_sort = WiredInTyCon mod tycon,
174 n_occ = mkSrcOccFS tcName fs, n_prov = SystemProv }
177 ---------------------------------------------------------------------
178 mkDerivedName :: (OccName -> OccName)
180 -> Unique -- New unique
181 -> Name -- Result is always a value name
183 mkDerivedName f name uniq = name {n_uniq = uniq, n_occ = f (n_occ name)}
185 -- mkUnboundName makes a place-holder Name; it shouldn't be looked at except possibly
186 -- during compiler debugging.
187 mkUnboundName :: RdrName -> Name
188 mkUnboundName rdr_name = mkLocalName unboundKey (rdrNameOcc rdr_name) noSrcLoc
190 isUnboundName :: Name -> Bool
191 isUnboundName name = name `hasKey` unboundKey
195 -- When we renumber/rename things, we need to be
196 -- able to change a Name's Unique to match the cached
197 -- one in the thing it's the name of. If you know what I mean.
198 setNameUnique name uniq = name {n_uniq = uniq}
200 setNameOcc :: Name -> OccName -> Name
201 -- Give the thing a new OccName, *and*
202 -- record that it's no longer a sys-local
203 -- This is used by the tidy-up pass
204 setNameOcc name occ = name {n_occ = occ}
206 setNameModule :: Name -> Module -> Name
207 setNameModule name mod = name {n_sort = set (n_sort name)}
209 set (Global _) = Global mod
210 set (WiredInId _ id) = WiredInId mod id
211 set (WiredInTyCon _ tycon) = WiredInTyCon mod tycon
215 %************************************************************************
217 \subsection{Setting provenance and visibility
219 %************************************************************************
221 tidyTopName is applied to top-level names in the final program
223 For top-level things, it globalises Local names
224 (if all top-level things should be visible)
225 and localises non-exported Global names
226 (if only exported things should be visible)
228 In all cases except an exported global, it gives it a new occurrence name.
230 The "visibility" here concerns whether the .o file's symbol table
231 mentions the thing; if so, it needs a module name in its symbol.
232 The Global things are "visible" and the Local ones are not
234 Why should things be "visible"? Certainly they must be if they
235 are exported. But also:
237 (a) In certain (prelude only) modules we split up the .hc file into
238 lots of separate little files, which are separately compiled by the C
239 compiler. That gives lots of little .o files. The idea is that if
240 you happen to mention one of them you don't necessarily pull them all
241 in. (Pulling in a piece you don't need can be v bad, because it may
242 mention other pieces you don't need either, and so on.)
244 Sadly, splitting up .hc files means that local names (like s234) are
245 now globally visible, which can lead to clashes between two .hc
246 files. So unlocaliseWhatnot goes through making all the local things
247 into global things, essentially by giving them full names so when they
248 are printed they'll have their module name too. Pretty revolting
251 (b) When optimisation is on we want to make all the internal
252 top-level defns externally visible
255 tidyTopName :: Module -> TidyOccEnv -> Name -> (TidyOccEnv, Name)
256 tidyTopName mod env name
259 (env', occ') = tidyOccName env (n_occ name)
261 name' = Name { n_uniq = n_uniq name, n_sort = mk_top_sort mod,
262 n_occ = occ', n_prov = LocalDef noSrcLoc NotExported }
264 mk_top_sort mod | all_toplev_ids_visible = Global mod
267 all_toplev_ids_visible =
268 not opt_OmitInterfacePragmas || -- Pragmas can make them visible
269 opt_EnsureSplittableC -- Splitting requires visiblilty
274 setNameProvenance :: Name -> Provenance -> Name
275 -- setNameProvenance used to only change the provenance of
276 -- Implicit-provenance things, but that gives bad error messages
277 -- for names defined twice in the same module, so I changed it to
278 -- set the provenance of *any* global (SLPJ Jun 97)
279 setNameProvenance name prov = name {n_prov = prov}
281 getNameProvenance :: Name -> Provenance
282 getNameProvenance name = n_prov name
284 setNameImportReason :: Name -> ImportReason -> Name
285 setNameImportReason name reason
286 = name { n_prov = new_prov }
288 -- It's important that we don't do the pattern matching
289 -- in the top-level clause, else we get a black hole in
290 -- the renamer. Rather a yukky constraint. There's only
291 -- one call, in RnNames
292 old_prov = n_prov name
293 new_prov = case old_prov of
294 NonLocalDef _ omit -> NonLocalDef reason omit
299 %************************************************************************
301 \subsection{Provenance and export info}
303 %************************************************************************
307 = LocalDef -- Defined locally
309 ExportFlag -- Whether it's exported
311 | NonLocalDef -- Defined non-locally
315 | SystemProv -- Either (a) a system-generated local with
316 -- a v short name OccName
317 -- or (b) a known-key global which should have a proper
318 -- provenance attached by the renamer
321 Sys-provs are only used internally. When the compiler generates (say)
322 a fresh desguar variable it always calls it "ds", and of course it gets
323 a fresh unique. But when printing -ddump-xx dumps, we must print it with
324 its unique, because there'll be a lot of "ds" variables.
326 Names with SystemProv differ in the following ways:
327 a) locals have unique attached when printing dumps
328 b) unifier eliminates sys tyvars in favour of user provs where possible
329 c) renamer replaces SystemProv with a better one
331 Before anything gets printed in interface files or output code, it's
332 fed through a 'tidy' processor, which zaps the OccNames to have
333 unique names; and converts all sys-locals to user locals
334 If any desugarer sys-locals have survived that far, they get changed to
339 = UserImport Module SrcLoc Bool -- Imported from module M on line L
340 -- Note the M may well not be the defining module
342 -- The Bool is true iff the thing was named *explicitly* in the import spec,
343 -- rather than being imported as part of a group; e.g.
346 -- Here, everything imported by B, and the constructors of T
347 -- are not named explicitly; only T is named explicitly.
348 -- This info is used when warning of unused names.
350 | ImplicitImport -- Imported implicitly for some other reason
353 type PrintUnqualified = Bool -- True <=> the unqualified name of this thing is
354 -- in scope in this module, so print it
355 -- unqualified in error messages
357 data ExportFlag = Exported | NotExported
360 Something is "Exported" if it may be mentioned by another module without
361 warning. The crucial thing about Exported things is that they must
362 never be dropped as dead code, even if they aren't used in this module.
363 Furthermore, being Exported means that we can't see all call sites of the thing.
365 Exported things include:
367 - explicitly exported Ids, including data constructors,
368 class method selectors
370 - dfuns from instance decls
372 Being Exported is *not* the same as finally appearing in the .o file's
373 symbol table. For example, a local Id may be mentioned in an Exported
374 Id's unfolding in the interface file, in which case the local Id goes
379 systemProvenance :: Provenance
380 systemProvenance = SystemProv
382 -- pprNameProvenance is used in error messages to say where a name came from
383 pprNameProvenance :: Name -> SDoc
384 pprNameProvenance name = pprProvenance (getNameProvenance name)
386 pprProvenance :: Provenance -> SDoc
387 pprProvenance SystemProv = ptext SLIT("System")
388 pprProvenance (LocalDef loc _) = ptext SLIT("defined at") <+> ppr loc
389 pprProvenance (NonLocalDef ImplicitImport _)
390 = ptext SLIT("implicitly imported")
391 pprProvenance (NonLocalDef (UserImport mod loc _) _)
392 = ptext SLIT("imported from") <+> ppr mod <+> ptext SLIT("at") <+> ppr loc
396 %************************************************************************
398 \subsection{Predicates and selectors}
400 %************************************************************************
403 nameUnique :: Name -> Unique
404 nameOccName :: Name -> OccName
405 nameModule :: Name -> Module
406 nameSrcLoc :: Name -> SrcLoc
407 isLocallyDefinedName :: Name -> Bool
408 isUserExportedName :: Name -> Bool
409 isWiredInName :: Name -> Bool
410 isLocalName :: Name -> Bool
411 isGlobalName :: Name -> Bool
412 isExternallyVisibleName :: Name -> Bool
416 hashName :: Name -> Int
417 hashName name = IBOX( u2i (nameUnique name) )
419 nameUnique name = n_uniq name
420 nameOccName name = n_occ name
424 Local -> pprPanic "nameModule" (ppr name)
425 x -> nameSortModule x
427 nameSortModule (Global mod) = mod
428 nameSortModule (WiredInId mod _) = mod
429 nameSortModule (WiredInTyCon mod _) = mod
431 nameRdrName :: Name -> RdrName
432 -- Makes a qualified name for top-level (Global) names, whether locally defined or not
433 -- and an unqualified name just for Locals
434 nameRdrName (Name { n_sort = Local, n_occ = occ }) = mkRdrUnqual occ
435 nameRdrName (Name { n_sort = sort, n_occ = occ }) = mkRdrQual (moduleName (nameSortModule sort)) occ
437 ifaceNameRdrName :: Name -> RdrName
438 -- Makes a qualified naem for imported things,
439 -- and an unqualified one for local things
440 ifaceNameRdrName n | isLocallyDefined n = mkRdrUnqual (nameOccName n)
441 | otherwise = mkRdrQual (moduleName (nameModule n)) (nameOccName n)
443 isUserExportedName (Name { n_prov = LocalDef _ Exported }) = True
444 isUserExportedName other = False
446 isUserImportedExplicitlyName (Name { n_prov = NonLocalDef (UserImport _ _ explicit) _ }) = explicit
447 isUserImportedExplicitlyName other = False
449 isUserImportedName (Name { n_prov = NonLocalDef (UserImport _ _ _) _ }) = True
450 isUserImportedName other = False
452 maybeUserImportedFrom (Name { n_prov = NonLocalDef (UserImport m _ _) _ }) = Just m
453 maybeUserImportedFrom other = Nothing
455 isDllName :: Name -> Bool
456 -- Does this name refer to something in a different DLL?
457 isDllName nm = not opt_Static &&
458 not (isLocallyDefinedName nm) &&
459 -- isLocallyDefinedName test is needed because nameModule won't work on local names
460 not (isLocalModule (nameModule nm))
462 nameSrcLoc name = provSrcLoc (n_prov name)
464 provSrcLoc (LocalDef loc _) = loc
465 provSrcLoc (NonLocalDef (UserImport _ loc _) _) = loc
466 provSrcLoc other = noSrcLoc
468 isLocallyDefinedName (Name {n_sort = Local}) = True -- Local (might have SystemProv)
469 isLocallyDefinedName (Name {n_prov = LocalDef _ _}) = True -- Global, but defined here
470 isLocallyDefinedName other = False -- Other
472 -- Things the compiler "knows about" are in some sense
473 -- "imported". When we are compiling the module where
474 -- the entities are defined, we need to be able to pick
475 -- them out, often in combination with isLocallyDefined.
476 isWiredInName (Name {n_sort = WiredInTyCon _ _}) = True
477 isWiredInName (Name {n_sort = WiredInId _ _}) = True
478 isWiredInName _ = False
480 maybeWiredInIdName :: Name -> Maybe Id
481 maybeWiredInIdName (Name {n_sort = WiredInId _ id}) = Just id
482 maybeWiredInIdName other = Nothing
484 maybeWiredInTyConName :: Name -> Maybe TyCon
485 maybeWiredInTyConName (Name {n_sort = WiredInTyCon _ tc}) = Just tc
486 maybeWiredInTyConName other = Nothing
489 isLocalName (Name {n_sort = Local}) = True
490 isLocalName _ = False
492 isGlobalName (Name {n_sort = Local}) = False
493 isGlobalName other = True
495 -- Global names are by definition those that are visible
496 -- outside the module, *as seen by the linker*. Externally visible
497 -- does not mean visible at the source level (that's isExported).
498 isExternallyVisibleName name = isGlobalName name
500 hasBetterProv :: Name -> Name -> Bool
502 -- a local thing over an imported thing
503 -- a user-imported thing over a non-user-imported thing
504 -- an explicitly-imported thing over an implicitly imported thing
506 = case (n_prov n1, n_prov n2) of
507 (LocalDef _ _, _ ) -> True
508 (NonLocalDef (UserImport _ _ True) _, _ ) -> True
509 (NonLocalDef (UserImport _ _ _ ) _, NonLocalDef ImplicitImport _) -> True
512 isSystemName (Name {n_prov = SystemProv}) = True
513 isSystemName other = False
517 %************************************************************************
519 \subsection[Name-instances]{Instance declarations}
521 %************************************************************************
524 cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2
528 instance Eq Name where
529 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
530 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
532 instance Ord Name where
533 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
534 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
535 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
536 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
537 compare a b = cmpName a b
539 instance Uniquable Name where
540 getUnique = nameUnique
542 instance NamedThing Name where
547 %************************************************************************
549 \subsection{Name environment}
551 %************************************************************************
554 type NameEnv a = UniqFM a -- Domain is Name
556 emptyNameEnv :: NameEnv a
557 mkNameEnv :: [(Name,a)] -> NameEnv a
558 nameEnvElts :: NameEnv a -> [a]
559 extendNameEnv_C :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a
560 extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a
561 plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
562 plusNameEnv_C :: (a->a->a) -> NameEnv a -> NameEnv a -> NameEnv a
563 extendNameEnvList:: NameEnv a -> [(Name,a)] -> NameEnv a
564 delFromNameEnv :: NameEnv a -> Name -> NameEnv a
565 elemNameEnv :: Name -> NameEnv a -> Bool
566 unitNameEnv :: Name -> a -> NameEnv a
567 lookupNameEnv :: NameEnv a -> Name -> Maybe a
568 lookupNameEnv_NF :: NameEnv a -> Name -> a
570 emptyNameEnv = emptyUFM
571 mkNameEnv = listToUFM
572 nameEnvElts = eltsUFM
573 extendNameEnv_C = addToUFM_C
574 extendNameEnv = addToUFM
575 plusNameEnv = plusUFM
576 plusNameEnv_C = plusUFM_C
577 extendNameEnvList= addListToUFM
578 delFromNameEnv = delFromUFM
579 elemNameEnv = elemUFM
580 unitNameEnv = unitUFM
582 lookupNameEnv = lookupUFM
583 lookupNameEnv_NF env n = expectJust "lookupNameEnv_NF" (lookupUFM env n)
587 %************************************************************************
589 \subsection{Pretty printing}
591 %************************************************************************
594 instance Outputable Name where
595 -- When printing interfaces, all Locals have been given nice print-names
596 ppr name = pprName name
598 pprName (Name {n_sort = Local, n_uniq = uniq, n_occ = occ, n_prov = prov})
600 = getPprStyle $ \ sty ->
601 if codeStyle sty then
602 pprUnique uniq -- When printing in code we required all names to
603 -- be globally unique; for example, we use this identifier
604 -- for the closure name. So we just print the unique alone.
606 pprOccName occ <> pp_local_extra sty uniq
608 sys_local = case prov of
612 pp_local_extra sty uniq
613 | sys_local = underscore <> pprUnique uniq -- Must print uniques for sys_locals
614 | debugStyle sty = text "{-" <> pprUnique uniq <> text "-}"
618 pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ, n_prov = prov})
619 -- Globals, and wired in things
620 = getPprStyle $ \ sty ->
621 if codeStyle sty then
622 ppr mod <> underscore <> ppr occ
624 pp_mod_dot sty <> ppr occ <> pp_global_debug sty uniq prov
626 mod = nameSortModule sort
630 SystemProv -> pp_qual mod user_sty
631 -- Hack alert! Omit the qualifier on SystemProv things in user style
632 -- I claim such SystemProv things will also be WiredIn things.
633 -- We can't get the omit flag right
634 -- on wired in tycons etc (sigh) so we just leave it out in user style,
635 -- and hope that leaving it out isn't too consfusing.
636 -- (e.g. if the programmer hides Bool and redefines it. If so, use -dppr-debug.)
638 LocalDef _ _ -> pp_qual mod (user_sty || iface_sty)
640 NonLocalDef (UserImport imp_mod _ _) omit
641 | user_sty -> pp_qual imp_mod omit
642 | otherwise -> pp_qual mod False
643 NonLocalDef ImplicitImport omit -> pp_qual mod (user_sty && omit)
645 user_sty = userStyle sty
646 iface_sty = ifaceStyle sty
648 pp_qual mod omit_qual
650 | otherwise = pprModule mod <> dot
652 pp_global_debug sty uniq prov
653 | debugStyle sty = hcat [text "{-", pprUnique uniq, prov_p prov, text "-}"]
656 prov_p prov | opt_PprStyle_NoPrags = empty
657 | otherwise = comma <> pp_prov prov
659 pp_prov (LocalDef _ Exported) = char 'x'
660 pp_prov (LocalDef _ NotExported) = char 'l'
661 pp_prov (NonLocalDef ImplicitImport _) = char 'j'
662 pp_prov (NonLocalDef (UserImport _ _ True ) _) = char 'I' -- Imported by name
663 pp_prov (NonLocalDef (UserImport _ _ False) _) = char 'i' -- Imported by ..
664 pp_prov SystemProv = char 's'
668 %************************************************************************
670 \subsection{Overloaded functions related to Names}
672 %************************************************************************
675 class NamedThing a where
676 getOccName :: a -> OccName
679 getOccName n = nameOccName (getName n) -- Default method
683 getSrcLoc :: NamedThing a => a -> SrcLoc
684 isLocallyDefined :: NamedThing a => a -> Bool
685 getOccString :: NamedThing a => a -> String
686 toRdrName :: NamedThing a => a -> RdrName
688 getSrcLoc = nameSrcLoc . getName
689 isLocallyDefined = isLocallyDefinedName . getName
690 getOccString x = occNameString (getOccName x)
691 toRdrName = ifaceNameRdrName . getName
695 {-# SPECIALIZE isLocallyDefined :: Name -> Bool #-}