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 -- Globals only
261 setNameProvenance (Global uniq mod occ def _) prov = Global uniq mod occ def prov
263 -- When we renumber/rename things, we need to be
264 -- able to change a Name's Unique to match the cached
265 -- one in the thing it's the name of. If you know what I mean.
266 changeUnique (Local _ n l) u = Local u n l
267 changeUnique (Global _ mod occ def prov) u = Global u mod occ def prov
269 setNameVisibility :: Module -> Name -> Name
270 -- setNameVisibility is applied to top-level names in the final program
271 -- The "visibility" here concerns whether the .o file's symbol table
272 -- mentions the thing; if so, it needs a module name in its symbol,
273 -- otherwise we just use its unique. The Global things are "visible"
274 -- and the local ones are not
276 setNameVisibility _ (Global uniq mod occ def (LocalDef NotExported loc))
277 | not all_toplev_ids_visible
280 setNameVisibility mod (Local uniq occ loc)
281 | all_toplev_ids_visible
283 (VarOcc (showUnique uniq)) -- It's local name must be unique!
284 VanillaDefn (LocalDef NotExported loc)
286 setNameVisibility mod name = name
288 all_toplev_ids_visible = not opt_OmitInterfacePragmas || -- Pragmas can make them visible
289 opt_EnsureSplittableC -- Splitting requires visiblilty
292 %************************************************************************
294 \subsection{Predicates and selectors}
296 %************************************************************************
299 nameUnique :: Name -> Unique
300 nameModAndOcc :: Name -> (Module, OccName) -- Globals only
301 nameOccName :: Name -> OccName
302 nameString :: Name -> FAST_STRING -- A.b form
303 nameSrcLoc :: Name -> SrcLoc
304 isLocallyDefinedName :: Name -> Bool
305 isExportedName :: Name -> Bool
306 isWiredInName :: Name -> Bool
307 isLocalName :: Name -> Bool
311 nameUnique (Local u _ _) = u
312 nameUnique (Global u _ _ _ _) = u
314 nameOccName (Local _ occ _) = occ
315 nameOccName (Global _ _ occ _ _) = occ
317 nameModAndOcc (Global _ mod occ _ _) = (mod,occ)
319 nameString (Local _ occ _) = occNameString occ
320 nameString (Global _ mod occ _ _) = mod _APPEND_ SLIT(".") _APPEND_ occNameString occ
322 isExportedName (Global _ _ _ _ (LocalDef Exported _)) = True
323 isExportedName other = False
325 nameSrcLoc (Local _ _ loc) = loc
326 nameSrcLoc (Global _ _ _ _ (LocalDef _ loc)) = loc
327 nameSrcLoc (Global _ _ _ _ (Imported _ loc)) = loc
328 nameSrcLoc other = noSrcLoc
330 isLocallyDefinedName (Local _ _ _) = True
331 isLocallyDefinedName (Global _ _ _ _ (LocalDef _ _)) = True
332 isLocallyDefinedName other = False
334 -- Things the compiler "knows about" are in some sense
335 -- "imported". When we are compiling the module where
336 -- the entities are defined, we need to be able to pick
337 -- them out, often in combination with isLocallyDefined.
338 isWiredInName (Global _ _ _ (WiredInTyCon _) _) = True
339 isWiredInName (Global _ _ _ (WiredInId _) _) = True
340 isWiredInName _ = False
342 maybeWiredInIdName :: Name -> Maybe Id
343 maybeWiredInIdName (Global _ _ _ (WiredInId id) _) = Just id
344 maybeWiredInIdName other = Nothing
346 maybeWiredInTyConName :: Name -> Maybe TyCon
347 maybeWiredInTyConName (Global _ _ _ (WiredInTyCon tc) _) = Just tc
348 maybeWiredInTyConName other = Nothing
351 isLocalName (Local _ _ _) = True
352 isLocalName _ = False
356 %************************************************************************
358 \subsection[Name-instances]{Instance declarations}
360 %************************************************************************
363 cmpName n1 n2 = c n1 n2
365 c (Local u1 _ _) (Local u2 _ _) = cmp u1 u2
366 c (Local _ _ _) _ = LT_
367 c (Global u1 _ _ _ _) (Global u2 _ _ _ _) = cmp u1 u2
368 c (Global _ _ _ _ _) _ = GT_
372 instance Eq Name where
373 a == b = case (a `cmp` b) of { EQ_ -> True; _ -> False }
374 a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True }
376 instance Ord Name where
377 a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True; GT__ -> False }
378 a < b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False }
379 a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True; GT__ -> True }
380 a > b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True }
382 instance Ord3 Name where
385 instance Uniquable Name where
386 uniqueOf = nameUnique
388 instance NamedThing Name where
394 %************************************************************************
396 \subsection{Pretty printing}
398 %************************************************************************
401 instance Outputable Name where
402 ppr sty (Local u n _) | codeStyle sty ||
403 ifaceStyle sty = pprUnique u
404 | otherwise = ppBesides [ppPStr (occNameString n), ppPStr SLIT("_"), pprUnique u]
406 ppr sty (Global u m n _ _) = ppBesides [pp_name, pp_uniq sty u]
408 pp_name | codeStyle sty = identToC qual_name
409 | otherwise = ppPStr qual_name
410 qual_name = m _APPEND_ SLIT(".") _APPEND_ occNameString n
412 pp_uniq PprDebug uniq = ppBesides [ppStr "{-", pprUnique uniq, ppStr "-}"]
413 pp_uniq other uniq = ppNil
415 -- pprNameProvenance is used in error messages to say where a name came from
416 pprNameProvenance :: PprStyle -> Name -> Pretty
417 pprNameProvenance sty (Local _ _ loc) = pprProvenance sty (LocalDef NotExported loc)
418 pprNameProvenance sty (Global _ _ _ _ prov) = pprProvenance sty prov
420 pprProvenance :: PprStyle -> Provenance -> Pretty
421 pprProvenance sty (Imported mod loc)
422 = ppSep [ppStr "Imported from", pprModule sty mod, ppStr "at", ppr sty loc]
423 pprProvenance sty (LocalDef _ loc)
424 = ppSep [ppStr "Defined at", ppr sty loc]
425 pprProvenance sty Implicit
426 = panic "pprNameProvenance: Implicit"
430 %************************************************************************
432 \subsection[Sets of names}
434 %************************************************************************
437 type NameSet = UniqSet Name
438 emptyNameSet :: NameSet
439 unitNameSet :: Name -> NameSet
440 addListToNameSet :: NameSet -> [Name] -> NameSet
441 mkNameSet :: [Name] -> NameSet
442 unionNameSets :: NameSet -> NameSet -> NameSet
443 unionManyNameSets :: [NameSet] -> NameSet
444 minusNameSet :: NameSet -> NameSet -> NameSet
445 elemNameSet :: Name -> NameSet -> Bool
446 nameSetToList :: NameSet -> [Name]
448 emptyNameSet = emptyUniqSet
449 unitNameSet = unitUniqSet
450 mkNameSet = mkUniqSet
451 addListToNameSet = addListToUniqSet
452 unionNameSets = unionUniqSets
453 unionManyNameSets = unionManyUniqSets
454 minusNameSet = minusUniqSet
455 elemNameSet = elementOfUniqSet
456 nameSetToList = uniqSetToList
461 %************************************************************************
463 \subsection{Overloaded functions related to Names}
465 %************************************************************************
468 class NamedThing a where
469 getOccName :: a -> OccName -- Even RdrNames can do this!
472 getOccName n = nameOccName (getName n) -- Default method
476 modAndOcc :: NamedThing a => a -> (Module, OccName)
477 getSrcLoc :: NamedThing a => a -> SrcLoc
478 isLocallyDefined :: NamedThing a => a -> Bool
479 isExported :: NamedThing a => a -> Bool
480 getOccString :: NamedThing a => a -> String
482 modAndOcc = nameModAndOcc . getName
483 isExported = isExportedName . getName
484 getSrcLoc = nameSrcLoc . getName
485 isLocallyDefined = isLocallyDefinedName . getName
486 pprSym sty = pprSymOcc sty . getOccName
487 pprNonSym sty = pprNonSymOcc sty . getOccName
488 getOccString x = _UNPK_ (occNameString (getOccName x))
492 {-# SPECIALIZE isLocallyDefined