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 (isLocalModule (nameModule nm))
460 nameSrcLoc name = provSrcLoc (n_prov name)
462 provSrcLoc (LocalDef loc _) = loc
463 provSrcLoc (NonLocalDef (UserImport _ loc _) _) = loc
464 provSrcLoc other = noSrcLoc
466 isLocallyDefinedName (Name {n_sort = Local}) = True -- Local (might have SystemProv)
467 isLocallyDefinedName (Name {n_prov = LocalDef _ _}) = True -- Global, but defined here
468 isLocallyDefinedName other = False -- Other
470 -- Things the compiler "knows about" are in some sense
471 -- "imported". When we are compiling the module where
472 -- the entities are defined, we need to be able to pick
473 -- them out, often in combination with isLocallyDefined.
474 isWiredInName (Name {n_sort = WiredInTyCon _ _}) = True
475 isWiredInName (Name {n_sort = WiredInId _ _}) = True
476 isWiredInName _ = False
478 maybeWiredInIdName :: Name -> Maybe Id
479 maybeWiredInIdName (Name {n_sort = WiredInId _ id}) = Just id
480 maybeWiredInIdName other = Nothing
482 maybeWiredInTyConName :: Name -> Maybe TyCon
483 maybeWiredInTyConName (Name {n_sort = WiredInTyCon _ tc}) = Just tc
484 maybeWiredInTyConName other = Nothing
487 isLocalName (Name {n_sort = Local}) = True
488 isLocalName _ = False
490 isGlobalName (Name {n_sort = Local}) = False
491 isGlobalName other = True
493 -- Global names are by definition those that are visible
494 -- outside the module, *as seen by the linker*. Externally visible
495 -- does not mean visible at the source level (that's isExported).
496 isExternallyVisibleName name = isGlobalName name
498 hasBetterProv :: Name -> Name -> Bool
500 -- a local thing over an imported thing
501 -- a user-imported thing over a non-user-imported thing
502 -- an explicitly-imported thing over an implicitly imported thing
504 = case (n_prov n1, n_prov n2) of
505 (LocalDef _ _, _ ) -> True
506 (NonLocalDef (UserImport _ _ True) _, _ ) -> True
507 (NonLocalDef (UserImport _ _ _ ) _, NonLocalDef ImplicitImport _) -> True
510 isSystemName (Name {n_prov = SystemProv}) = True
511 isSystemName other = False
515 %************************************************************************
517 \subsection[Name-instances]{Instance declarations}
519 %************************************************************************
522 cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2
526 instance Eq Name where
527 a == b = case (a `compare` b) of { EQ -> True; _ -> False }
528 a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
530 instance Ord Name where
531 a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False }
532 a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False }
533 a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True }
534 a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True }
535 compare a b = cmpName a b
537 instance Uniquable Name where
538 getUnique = nameUnique
540 instance NamedThing Name where
545 %************************************************************************
547 \subsection{Name environment}
549 %************************************************************************
552 type NameEnv a = UniqFM a -- Domain is Name
554 emptyNameEnv :: NameEnv a
555 mkNameEnv :: [(Name,a)] -> NameEnv a
556 nameEnvElts :: NameEnv a -> [a]
557 extendNameEnv_C :: (a->a->a) -> NameEnv a -> Name -> a -> NameEnv a
558 extendNameEnv :: NameEnv a -> Name -> a -> NameEnv a
559 plusNameEnv :: NameEnv a -> NameEnv a -> NameEnv a
560 plusNameEnv_C :: (a->a->a) -> NameEnv a -> NameEnv a -> NameEnv a
561 extendNameEnvList:: NameEnv a -> [(Name,a)] -> NameEnv a
562 delFromNameEnv :: NameEnv a -> Name -> NameEnv a
563 elemNameEnv :: Name -> NameEnv a -> Bool
564 unitNameEnv :: Name -> a -> NameEnv a
565 lookupNameEnv :: NameEnv a -> Name -> Maybe a
566 lookupNameEnv_NF :: NameEnv a -> Name -> a
568 emptyNameEnv = emptyUFM
569 mkNameEnv = listToUFM
570 nameEnvElts = eltsUFM
571 extendNameEnv_C = addToUFM_C
572 extendNameEnv = addToUFM
573 plusNameEnv = plusUFM
574 plusNameEnv_C = plusUFM_C
575 extendNameEnvList= addListToUFM
576 delFromNameEnv = delFromUFM
577 elemNameEnv = elemUFM
578 unitNameEnv = unitUFM
580 lookupNameEnv = lookupUFM
581 lookupNameEnv_NF env n = expectJust "lookupNameEnv_NF" (lookupUFM env n)
585 %************************************************************************
587 \subsection{Pretty printing}
589 %************************************************************************
592 instance Outputable Name where
593 -- When printing interfaces, all Locals have been given nice print-names
594 ppr name = pprName name
596 pprName (Name {n_sort = Local, n_uniq = uniq, n_occ = occ, n_prov = prov})
598 = getPprStyle $ \ sty ->
599 if codeStyle sty then
600 pprUnique uniq -- When printing in code we required all names to
601 -- be globally unique; for example, we use this identifier
602 -- for the closure name. So we just print the unique alone.
604 pprOccName occ <> pp_local_extra sty uniq
606 sys_local = case prov of
610 pp_local_extra sty uniq
611 | sys_local = underscore <> pprUnique uniq -- Must print uniques for sys_locals
612 | debugStyle sty = text "{-" <> pprUnique uniq <> text "-}"
616 pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ, n_prov = prov})
617 -- Globals, and wired in things
618 = getPprStyle $ \ sty ->
619 if codeStyle sty then
620 ppr mod <> underscore <> ppr occ
622 pp_mod_dot sty <> ppr occ <> pp_global_debug sty uniq prov
624 mod = nameSortModule sort
628 SystemProv -> pp_qual mod user_sty
629 -- Hack alert! Omit the qualifier on SystemProv things in user style
630 -- I claim such SystemProv things will also be WiredIn things.
631 -- We can't get the omit flag right
632 -- on wired in tycons etc (sigh) so we just leave it out in user style,
633 -- and hope that leaving it out isn't too consfusing.
634 -- (e.g. if the programmer hides Bool and redefines it. If so, use -dppr-debug.)
636 LocalDef _ _ -> pp_qual mod (user_sty || iface_sty)
638 NonLocalDef (UserImport imp_mod _ _) omit
639 | user_sty -> pp_qual imp_mod omit
640 | otherwise -> pp_qual mod False
641 NonLocalDef ImplicitImport omit -> pp_qual mod (user_sty && omit)
643 user_sty = userStyle sty
644 iface_sty = ifaceStyle sty
646 pp_qual mod omit_qual
648 | otherwise = pprModule mod <> dot
650 pp_global_debug sty uniq prov
651 | debugStyle sty = hcat [text "{-", pprUnique uniq, prov_p prov, text "-}"]
654 prov_p prov | opt_PprStyle_NoPrags = empty
655 | otherwise = comma <> pp_prov prov
657 pp_prov (LocalDef _ Exported) = char 'x'
658 pp_prov (LocalDef _ NotExported) = char 'l'
659 pp_prov (NonLocalDef ImplicitImport _) = char 'j'
660 pp_prov (NonLocalDef (UserImport _ _ True ) _) = char 'I' -- Imported by name
661 pp_prov (NonLocalDef (UserImport _ _ False) _) = char 'i' -- Imported by ..
662 pp_prov SystemProv = char 's'
666 %************************************************************************
668 \subsection{Overloaded functions related to Names}
670 %************************************************************************
673 class NamedThing a where
674 getOccName :: a -> OccName
677 getOccName n = nameOccName (getName n) -- Default method
681 getSrcLoc :: NamedThing a => a -> SrcLoc
682 isLocallyDefined :: NamedThing a => a -> Bool
683 getOccString :: NamedThing a => a -> String
684 toRdrName :: NamedThing a => a -> RdrName
686 getSrcLoc = nameSrcLoc . getName
687 isLocallyDefined = isLocallyDefinedName . getName
688 getOccString x = occNameString (getOccName x)
689 toRdrName = ifaceNameRdrName . getName
693 {-# SPECIALIZE isLocallyDefined :: Name -> Bool #-}