2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1996
4 \section[Name]{@Name@: to transmit name info from renamer to typechecker}
7 #include "HsVersions.h"
12 pprModule, moduleString,
16 pprOccName, pprSymOcc, pprNonSymOcc, occNameString, occNameFlavour, isTvOcc,
17 quoteInText, parenInCode,
21 mkLocalName, mkSysLocalName,
23 mkCompoundName, mkGlobalName, mkInstDeclName,
25 mkWiredInIdName, mkWiredInTyConName,
26 maybeWiredInIdName, maybeWiredInTyConName,
29 nameUnique, changeUnique, setNameProvenance, setNameVisibility,
30 nameOccName, nameString,
31 isExportedName, nameSrcLoc,
40 emptyNameSet, unitNameSet, mkNameSet, unionNameSets, unionManyNameSets,
41 minusNameSet, elemNameSet, nameSetToList, addListToNameSet,
45 Provenance(..), pprProvenance,
48 -- Class NamedThing and overloaded friends
50 modAndOcc, isExported,
51 getSrcLoc, isLocallyDefined, getOccString,
57 import TyLoop ( GenId, Id(..), TyCon ) -- Used inside Names
58 import CStrings ( identToC, modnameToC, cSEP )
59 import CmdLineOpts ( opt_OmitInterfacePragmas, opt_EnsureSplittableC )
61 import Outputable ( Outputable(..) )
62 import PprStyle ( PprStyle(..), codeStyle, ifaceStyle )
63 import PrelMods ( gHC__ )
65 import Lex ( isLexSym, isLexConId )
66 import SrcLoc ( noSrcLoc, SrcLoc )
67 import Unique ( pprUnique, showUnique, Unique )
68 import UniqSet ( UniqSet(..), emptyUniqSet, unitUniqSet, unionUniqSets, uniqSetToList,
69 unionManyUniqSets, minusUniqSet, mkUniqSet, elementOfUniqSet, addListToUniqSet )
70 import UniqFM ( UniqFM )
71 import Util ( cmpPString, panic, assertPanic {-, pprTrace ToDo:rm-} )
75 %************************************************************************
77 \subsection[Name-pieces-datatypes]{The @Module@, @OccName@ datatypes}
79 %************************************************************************
82 type Module = FAST_STRING
84 data OccName = VarOcc FAST_STRING -- Variables and data constructors
85 | TvOcc FAST_STRING -- Type variables
86 | TCOcc FAST_STRING -- Type constructors and classes
88 moduleString :: Module -> String
89 moduleString mod = _UNPK_ mod
91 pprModule :: PprStyle -> Module -> Pretty
92 pprModule sty m = ppPStr m
94 pprOccName :: PprStyle -> OccName -> Pretty
95 pprOccName PprDebug n = ppCat [ppPStr (occNameString n), ppBracket (ppStr (occNameFlavour n))]
96 pprOccName sty n = if codeStyle sty
97 then identToC (occNameString n)
98 else ppPStr (occNameString n)
100 occNameString :: OccName -> FAST_STRING
101 occNameString (VarOcc s) = s
102 occNameString (TvOcc s) = s
103 occNameString (TCOcc s) = s
105 -- occNameFlavour is used only to generate good error messages, so it doesn't matter
106 -- that the VarOcc case isn't mega-efficient. We could have different Occ constructors for
107 -- data constructors and values, but that makes everything else a bit more complicated.
108 occNameFlavour :: OccName -> String
109 occNameFlavour (VarOcc s) | isLexConId s = "data constructor"
110 | otherwise = "value"
111 occNameFlavour (TvOcc s) = "type variable"
112 occNameFlavour (TCOcc s) = "type constructor or class"
114 isTvOcc :: OccName -> Bool
115 isTvOcc (TvOcc s) = True
116 isTvOcc other = False
118 instance Eq OccName where
119 a == b = case (a `cmp` b) of { EQ_ -> True; _ -> False }
120 a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True }
122 instance Ord OccName where
123 a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True; GT__ -> False }
124 a < b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False }
125 a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True; GT__ -> True }
126 a > b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True }
128 instance Ord3 OccName where
131 (VarOcc s1) `cmpOcc` (VarOcc s2) = s1 `_CMP_STRING_` s2
132 (VarOcc s1) `cmpOcc` other2 = LT_
134 (TvOcc s1) `cmpOcc` (VarOcc s2) = GT_
135 (TvOcc s1) `cmpOcc` (TvOcc s2) = s1 `_CMP_STRING_` s2
136 (TvOcc s1) `cmpOcc` other = LT_
138 (TCOcc s1) `cmpOcc` (TCOcc s2) = s1 `_CMP_STRING_` s2
139 (TCOcc s1) `cmpOcc` other = GT_
141 instance Outputable OccName where
147 parenInCode, quoteInText :: OccName -> Bool
148 parenInCode occ = isLexSym (occNameString occ)
150 quoteInText occ = not (isLexSym (occNameString occ))
152 -- print `vars`, (op) correctly
153 pprSymOcc, pprNonSymOcc :: PprStyle -> OccName -> Pretty
157 then ppQuote (pprOccName sty var)
158 else pprOccName sty var
162 then ppParens (pprOccName sty var)
163 else pprOccName sty var
166 %************************************************************************
168 \subsection[Name-datatype]{The @Name@ datatype, and name construction}
170 %************************************************************************
179 Module -- The defining module
180 OccName -- Its name in that module
181 DefnInfo -- How it is defined
182 Provenance -- How it was brought into scope
185 Things with a @Global@ name are given C static labels, so they finally
186 appear in the .o file's symbol table. They appear in the symbol table
187 in the form M.n. If originally-local things have this property they
188 must be made @Global@ first.
191 data DefnInfo = VanillaDefn
192 | WiredInTyCon TyCon -- There's a wired-in version
193 | WiredInId Id -- ...ditto...
196 = LocalDef ExportFlag SrcLoc -- Locally defined
197 | Imported Module SrcLoc -- Directly imported from M; gives locn of import statement
198 | Implicit -- Implicitly imported
201 Something is "Exported" if it may be mentioned by another module without
202 warning. The crucial thing about Exported things is that they must
203 never be dropped as dead code, even if they aren't used in this module.
204 Furthermore, being Exported means that we can't see all call sites of the thing.
206 Exported things include:
207 - explicitly exported Ids, including data constructors, class method selectors
208 - dfuns from instance decls
210 Being Exported is *not* the same as finally appearing in the .o file's
211 symbol table. For example, a local Id may be mentioned in an Exported
212 Id's unfolding in the interface file, in which case the local Id goes
216 data ExportFlag = Exported | NotExported
220 mkLocalName :: Unique -> OccName -> SrcLoc -> Name
223 mkGlobalName :: Unique -> Module -> OccName -> DefnInfo -> Provenance -> Name
224 mkGlobalName = Global
226 mkSysLocalName :: Unique -> FAST_STRING -> SrcLoc -> Name
227 mkSysLocalName uniq str loc = Local uniq (VarOcc str) loc
229 mkWiredInIdName :: Unique -> Module -> FAST_STRING -> Id -> Name
230 mkWiredInIdName uniq mod occ id
231 = Global uniq mod (VarOcc occ) (WiredInId id) Implicit
233 mkWiredInTyConName :: Unique -> Module -> FAST_STRING -> TyCon -> Name
234 mkWiredInTyConName uniq mod occ tycon
235 = Global uniq mod (TCOcc occ) (WiredInTyCon tycon) Implicit
238 mkCompoundName :: (FAST_STRING -> FAST_STRING) -- Occurrence-name modifier
239 -> Unique -- New unique
240 -> Name -- Base name (must be a Global)
241 -> Name -- Result is always a value name
243 mkCompoundName str_fn uniq (Global _ mod occ defn prov)
244 = Global uniq mod new_occ defn prov
246 new_occ = VarOcc (str_fn (occNameString occ)) -- Always a VarOcc
248 mkCompoundName str_fn uniq (Local _ occ loc)
249 = Local uniq (VarOcc (str_fn (occNameString occ))) loc
251 -- Rather a wierd one that's used for names generated for instance decls
252 mkInstDeclName :: Unique -> Module -> OccName -> SrcLoc -> Bool -> Name
253 mkInstDeclName uniq mod occ loc from_here
254 = Global uniq mod occ VanillaDefn prov
256 prov | from_here = LocalDef Exported loc
257 | otherwise = Implicit
260 setNameProvenance :: Name -> Provenance -> Name -- Implicit Globals only
261 setNameProvenance (Global uniq mod occ def Implicit) prov = Global uniq mod occ def prov
262 setNameProvenance other_name prov = other_name
264 -- When we renumber/rename things, we need to be
265 -- able to change a Name's Unique to match the cached
266 -- one in the thing it's the name of. If you know what I mean.
267 changeUnique (Local _ n l) u = Local u n l
268 changeUnique (Global _ mod occ def prov) u = Global u mod occ def prov
270 setNameVisibility :: Module -> Name -> Name
271 -- setNameVisibility is applied to top-level names in the final program
272 -- The "visibility" here concerns whether the .o file's symbol table
273 -- mentions the thing; if so, it needs a module name in its symbol,
274 -- otherwise we just use its unique. The Global things are "visible"
275 -- and the local ones are not
277 setNameVisibility _ (Global uniq mod occ def (LocalDef NotExported loc))
278 | not all_toplev_ids_visible
281 setNameVisibility mod (Local uniq occ loc)
282 | all_toplev_ids_visible
284 (VarOcc (showUnique uniq)) -- It's local name must be unique!
285 VanillaDefn (LocalDef NotExported loc)
287 setNameVisibility mod name = name
289 all_toplev_ids_visible = not opt_OmitInterfacePragmas || -- Pragmas can make them visible
290 opt_EnsureSplittableC -- Splitting requires visiblilty
293 %************************************************************************
295 \subsection{Predicates and selectors}
297 %************************************************************************
300 nameUnique :: Name -> Unique
301 nameModAndOcc :: Name -> (Module, OccName) -- Globals only
302 nameOccName :: Name -> OccName
303 nameString :: Name -> FAST_STRING -- A.b form
304 nameSrcLoc :: Name -> SrcLoc
305 isLocallyDefinedName :: Name -> Bool
306 isExportedName :: Name -> Bool
307 isWiredInName :: Name -> Bool
308 isLocalName :: Name -> Bool
312 nameUnique (Local u _ _) = u
313 nameUnique (Global u _ _ _ _) = u
315 nameOccName (Local _ occ _) = occ
316 nameOccName (Global _ _ occ _ _) = occ
318 nameModAndOcc (Global _ mod occ _ _) = (mod,occ)
320 nameString (Local _ occ _) = occNameString occ
321 nameString (Global _ mod occ _ _) = mod _APPEND_ SLIT(".") _APPEND_ occNameString occ
323 isExportedName (Global _ _ _ _ (LocalDef Exported _)) = True
324 isExportedName other = False
326 nameSrcLoc (Local _ _ loc) = loc
327 nameSrcLoc (Global _ _ _ _ (LocalDef _ loc)) = loc
328 nameSrcLoc (Global _ _ _ _ (Imported _ loc)) = loc
329 nameSrcLoc other = noSrcLoc
331 isLocallyDefinedName (Local _ _ _) = True
332 isLocallyDefinedName (Global _ _ _ _ (LocalDef _ _)) = True
333 isLocallyDefinedName other = False
335 -- Things the compiler "knows about" are in some sense
336 -- "imported". When we are compiling the module where
337 -- the entities are defined, we need to be able to pick
338 -- them out, often in combination with isLocallyDefined.
339 isWiredInName (Global _ _ _ (WiredInTyCon _) _) = True
340 isWiredInName (Global _ _ _ (WiredInId _) _) = True
341 isWiredInName _ = False
343 maybeWiredInIdName :: Name -> Maybe Id
344 maybeWiredInIdName (Global _ _ _ (WiredInId id) _) = Just id
345 maybeWiredInIdName other = Nothing
347 maybeWiredInTyConName :: Name -> Maybe TyCon
348 maybeWiredInTyConName (Global _ _ _ (WiredInTyCon tc) _) = Just tc
349 maybeWiredInTyConName other = Nothing
352 isLocalName (Local _ _ _) = True
353 isLocalName _ = False
357 %************************************************************************
359 \subsection[Name-instances]{Instance declarations}
361 %************************************************************************
364 cmpName n1 n2 = c n1 n2
366 c (Local u1 _ _) (Local u2 _ _) = cmp u1 u2
367 c (Local _ _ _) _ = LT_
368 c (Global u1 _ _ _ _) (Global u2 _ _ _ _) = cmp u1 u2
369 c (Global _ _ _ _ _) _ = GT_
373 instance Eq Name where
374 a == b = case (a `cmp` b) of { EQ_ -> True; _ -> False }
375 a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True }
377 instance Ord Name where
378 a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True; GT__ -> False }
379 a < b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False }
380 a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True; GT__ -> True }
381 a > b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True }
383 instance Ord3 Name where
386 instance Uniquable Name where
387 uniqueOf = nameUnique
389 instance NamedThing Name where
395 %************************************************************************
397 \subsection{Pretty printing}
399 %************************************************************************
402 instance Outputable Name where
403 ppr sty (Local u n _) | codeStyle sty ||
404 ifaceStyle sty = pprUnique u
405 ppr PprForUser (Local _ n _) = ppPStr (occNameString n)
406 ppr other_sty (Local u n _) = ppBesides [ppPStr (occNameString n), ppPStr SLIT("_"), pprUnique u]
408 ppr sty name@(Global u m n _ _) = ppBesides [pp_name, pp_debug sty name]
410 pp_name | codeStyle sty = identToC qual_name
411 | otherwise = ppPStr qual_name
412 qual_name = m _APPEND_ SLIT(".") _APPEND_ occNameString n
414 pp_debug PprDebug (Global uniq m n _ prov) = ppBesides [ppStr "{-", pprUnique uniq, ppStr ",",
415 pp_prov prov, ppStr "-}"]
417 pp_prov (LocalDef _ _) = ppChar 'l'
418 pp_prov (Imported _ _) = ppChar 'i'
419 pp_prov Implicit = ppChar 'p'
420 pp_debug other name = ppNil
422 -- pprNameProvenance is used in error messages to say where a name came from
423 pprNameProvenance :: PprStyle -> Name -> Pretty
424 pprNameProvenance sty (Local _ _ loc) = pprProvenance sty (LocalDef NotExported loc)
425 pprNameProvenance sty (Global _ _ _ _ prov) = pprProvenance sty prov
427 pprProvenance :: PprStyle -> Provenance -> Pretty
428 pprProvenance sty (Imported mod loc)
429 = ppSep [ppStr "Imported from", pprModule sty mod, ppStr "at", ppr sty loc]
430 pprProvenance sty (LocalDef _ loc)
431 = ppSep [ppStr "Defined at", ppr sty loc]
432 pprProvenance sty Implicit
433 = panic "pprNameProvenance: Implicit"
437 %************************************************************************
439 \subsection[Sets of names}
441 %************************************************************************
444 type NameSet = UniqSet Name
445 emptyNameSet :: NameSet
446 unitNameSet :: Name -> NameSet
447 addListToNameSet :: NameSet -> [Name] -> NameSet
448 mkNameSet :: [Name] -> NameSet
449 unionNameSets :: NameSet -> NameSet -> NameSet
450 unionManyNameSets :: [NameSet] -> NameSet
451 minusNameSet :: NameSet -> NameSet -> NameSet
452 elemNameSet :: Name -> NameSet -> Bool
453 nameSetToList :: NameSet -> [Name]
455 emptyNameSet = emptyUniqSet
456 unitNameSet = unitUniqSet
457 mkNameSet = mkUniqSet
458 addListToNameSet = addListToUniqSet
459 unionNameSets = unionUniqSets
460 unionManyNameSets = unionManyUniqSets
461 minusNameSet = minusUniqSet
462 elemNameSet = elementOfUniqSet
463 nameSetToList = uniqSetToList
468 %************************************************************************
470 \subsection{Overloaded functions related to Names}
472 %************************************************************************
475 class NamedThing a where
476 getOccName :: a -> OccName -- Even RdrNames can do this!
479 getOccName n = nameOccName (getName n) -- Default method
483 modAndOcc :: NamedThing a => a -> (Module, OccName)
484 getSrcLoc :: NamedThing a => a -> SrcLoc
485 isLocallyDefined :: NamedThing a => a -> Bool
486 isExported :: NamedThing a => a -> Bool
487 getOccString :: NamedThing a => a -> String
489 modAndOcc = nameModAndOcc . getName
490 isExported = isExportedName . getName
491 getSrcLoc = nameSrcLoc . getName
492 isLocallyDefined = isLocallyDefinedName . getName
493 pprSym sty = pprSymOcc sty . getOccName
494 pprNonSym sty = pprNonSymOcc sty . getOccName
495 getOccString x = _UNPK_ (occNameString (getOccName x))
499 {-# SPECIALIZE isLocallyDefined